2 research outputs found
Self-managing cloud-native applications : design, implementation and experience
Running applications in the cloud efficiently requires much more than deploying software in virtual machines. Cloud applications have to be continuously managed: (1) to adjust their resources to the incoming load and (2) to face transient failures replicating and restarting components to provide resiliency on unreliable infrastructure. Continuous management monitors application and infrastructural metrics to provide automated and responsive reactions to failures (health management) and changing environmental conditions (auto-scaling) minimizing human intervention.
In the current practice, management functionalities are provided as infrastructural or third party services. In both cases they are external to the application deployment. We claim that this approach has intrinsic limits, namely that separating management functionalities from the application prevents them from naturally scaling with the application and requires additional management code and human intervention. Moreover, using infrastructure provider services for management functionalities results in vendor lock-in effectively preventing cloud applications to adapt and run on the most effective cloud for the job.
In this paper we discuss the main characteristics of cloud native applications, propose a novel architecture that enables scalable and resilient self-managing applications in the cloud, and relate on our experience in porting a legacy application to the cloud applying cloud-native principles
Robust Contract Evolution in a TypeSafe MicroServices Architecture
Microservices architectures allow for short deployment cycles and immediate
effects but offer no safety mechanisms when service contracts need to be
changed. Maintaining the soundness of microservice architectures is an
error-prone task that is only accessible to the most disciplined development
teams. We present a microservice management system that statically verifies
service interfaces and supports the seamless evolution of compatible
interfaces. We define a compatibility relation that captures real evolution
patterns and embodies known good practices on the evolution of interfaces.
Namely, we allow for the addition, removal, and renaming of data fields of a
producer module without breaking or needing to upgrade consumer services. The
evolution of interfaces is supported by runtime generated proxy components that
dynamically adapt data exchanged between services to match with the statically
checked service code.The model was instantiated in a core language whose
semantics is defined by a labeled transition system and a type system that
prevents breaking changes from being deployed. Standard soundness results for
the core language entail the existence of adapters, hence the absence of
adaptation errors and the correctness of the management model. This adaptive
approach allows for gradual deployment of modules, without halting the whole
system and avoiding losing or misinterpreting data exchanged between system
nodes. Experimental data shows that an average of 69% of deployments that would
require adaptation and recompilation are safe under our approach