Design patterns for container-based distributed systems
Brendan Burns David Oppenheimer
Google
1 Introduction
In the late 1980s and early 1990s, object-oriented pro-
gramming revolutionized software development, popu-
larizing the approach of building of applications as col-
lections of modular components. Today we are seeing
a similar revolution in distributed system development,
with the increasing popularity of microservice archi-
tectures built from containerized software components.
Containers [15] [22] [1] [2] are particularly well-suited
as the fundamental “object” in distributed systems by
virtue of the walls they erect at the container bound-
ary. As this architectural style matures, we are seeing the
emergence of design patterns, much as we did for object-
oriented programs, and for the same reason – thinking in
terms of objects (or containers) abstracts away the low-
level details of code, eventually revealing higher-level
patterns that are common to a variety of applications and
algorithms.
This paper describes three types of design patterns
that we have observed emerging in container-based dis-
tributed systems: single-container patterns for container
management, single-node patterns of closely cooperat-
ing containers, and multi-node patterns for distributed
algorithms. Like object-oriented patterns before them,
these patterns for distributed computation encode best
practices, simplify development, and make the systems
where they are used more reliable.
2 Distributed system design patterns
After object-oriented programming had been used for
some years, design patterns emerged and were docu-
mented [3]. These patterns codified and regularized gen-
eral approaches to solving particular common program-
ming problems. This codification further improved the
general state of the art in programming because it made it
easier for less experienced programmers to produce well-
engineered code, and led to the development of reusable
libraries that made code more reliable and faster to de-
velop.
The state-of-the-art in distributed system engineering
today looks significantly more like the world of early
1980s programming than it does the world of object-
oriented development. Yet it’s clear from the success
of the MapReduce pattern [4] in bringing the power of
“Big Data” programming to a broad set of fields and de-
velopers, that putting in place the right set of patterns
can dramatically improve the quality, speed, and acces-
sibility of distributed system programming. But even the
success of MapReduce is largely limited to a single pro-
gramming language, insofar as the Apache Hadoop [5]
ecosystem is primarily written in and for Java. Develop-
ing a truly comprehensive suite of patterns for distributed
system design requires a very generic, language-neutral
vehicle to represent the atoms of the system.
Thus it is fortunate that the last two years have seen a
dramatic rise in adoption of Linux container technology.
The container and the container image are exactly the ab-
stractions needed for the development of distributed sys-
tems patterns. To date, containers and container images
have achieved the large measure of their popularity sim-
ply by being a better, more reliable method for delivering
software from development all the way through produc-
tion. By being hermetically sealed, carrying their depen-
dencies with them, and providing an atomic deployment
signal (“succeeded”/“failed”), they dramatically improve
on the previous state of the art in deploying software in
the datacenter or cloud. But containers have the potential
to be much more than just a better deployment vehicle
– we believe they are destined to become analogous to
objects in object-oriented software systems, and as such
will enable the development of distributed system design
patterns. In the following sections we explain why we
believe this to be the case, and describe some patterns
that we see emerging to regularize and guide the engi-
neering of distributed systems over the coming years.
1
