Cloud Native architectures, such as those built on Kubernetes, are envied for their ability to segment different parts of an application into microservices that can separately be containerized, so that each microservice can be written in its own language, with its own framework, and its unique set of libraries. This has been shown to significantly increase developer and team productivity by decoupling dependencies between different parts of a team.
However, most legacy code consists of a large monolithic code base, not microservices applications. And, the lesson of second system syndrome is that many attempted code rewrites will end in failure, as the first system will evolve faster than the replacement system can be developed to displace it. A cloud native architecture that is only useful for new greenfield deployments is not very useful at all.
So, how can monoliths evolve into modern cloud native architectures, in order to take advantage of the dev ops revolution and the resulting developer productivity gains?
This talk will look at several real-world cases where existing monolithic, legacy applications deployed in multi-billion dollar companies were slowly evolved into cloud native microservices architectures on Kubernetes. They did so step-by-step, shaving off individual pieces of functionality into new applications that were packaged into new microservices applications, until the original monolith was eventually cut down to a reasonable size. In doing so, they demonstrated that the cloud native architecture is suitable across most categories of computing, including both greenfield and brownfield development.