Consistent Updates for Scalable Microservices

TL;DR

This paper introduces a formal framework and algorithms to enable consistent, atomic updates in scalable microservice architectures, addressing the challenge of avoiding inconsistencies during live service modifications.

Contribution

It develops the first algorithms guaranteeing update consistency in microservices by leveraging semantic properties like commutativity, advancing the theory of live service updates.

Findings

Algorithms guarantee update consistency during live updates.

Semantic properties like commutativity are essential for consistency.

Any oblivious update method risks inconsistencies.

Abstract

Online services are commonly implemented with a scalable microservice architecture, where isomorphic workers process client requests, recording persistent state in a backend data store. To maintain service, modifications to service functionality must be made on the fly -- i.e., as the service continues to process client requests -- but doing so is challenging. The central difficulty is that of avoiding inconsistencies from mixed-mode operation, caused by workers of current and new versions interacting via the data store. Some update methods avoid mixed-mode altogether, but only at the cost of substantial inefficiency -- by doubling resources (memory and compute), or by halving throughput. The alternative is an uncontrolled ``rolling'' update, which runs the risk of serious service failures arising from inconsistent mixed-mode behavior. Ideally, it should appear to every client that a service update takes effect atomically; this ensures that a client is not exposed to inconsistent mixed-mode behavior. In this paper, we introduce a framework that formalizes this intuition and develop foundational theory for reasoning about update consistency. We apply this theory to derive the first algorithms that guarantee consistency for mixed-mode updates. The algorithms rely on semantic properties of service actions, such as commutativity. We show that this is unavoidable, by proving that any semantically oblivious mixed-mode update method must allow inconsistencies.