Kubernetes is emblematic of a movement in technology -- a movement away from monolithic architectures, towards what’s known as microservices architecture, where services are decoupled, isolated, and only as big as they absolutely have to be. These individual microservices are deployed in containers that are launched in seconds and may be terminated only after minutes of usage.
So, why go through the work of unbundling and containerizing your monolith if the end result is near-identical to an end user? Simple: it’s easier to develop and maintain in nearly every way. From executing upgrades, to allocating resources with precision, to isolating performance issues, the advantages of a microservices architecture over a monolithic one are vast.
In this guide, we’ll go over everything you need to know to begin preparing your applications for life in cloud containers. But first, let’s start with some basic ideas you’ll see mentioned throughout all of these chapters.
Key Terms & Concepts
- Containers: A standalone, executable package of software that includes all necessary code and dependencies.
- Immutable Architecture: An infrastructure paradigm where servers are never modified, only replaced.
- Infrastructure-as-Code: The practice of provisioning and managing data center resources using humanly-readable declarative definition files (e.g., YAML).
- Microservices: A series of independently deployable software services that, together, make up an application.
- Vertical Scaling: Where you allocate more CPU or memory to your individual machines or containers.
- Horizontal Scaling: Where you add more machines or containers to your load-balanced computing resource pool.
Putting it all Together
By decoupling your services and converting them into micro services, you enable containerization for each individual service. This containerization compartmentalizes any resource needs, configuration needs, and performance issues for a particular service--allowing your engineering department to align individual contributors with teams specialized to support a unique tech stack best tailored to power that service. Once containerized, your architecture can then become immutable to ensure the stability of production environments while also allowing for accurate and thorough testing of new image configurations.
Each of the following chapters provides a deeper look into the concepts, best practices, and challenges of transitioning to a Kubernetes-based containerized set of microservices.
Learn why containers are more lightweight, faster to deploy, and easy to terminate when compared to virtual machines.
Get some guidance on how to prepare your organization for success when converting from monolithic- to microservice-based architecture.
Discover why mutable architecture is more vulnerable to performance issues than immutable architecture and how you can employ infrastructure-as-code methodologies and tools to easily manage your servers.
Understand the challenges unique to containerization regarding deployment, lifecycle management, network configuration, and scaling -- and how Kuberenetes solves them.
Walk through the evolution of Kubernetes since its origins, the main reasons for its dominance, and its rise to a highly automated and extensible platform configured with declarative files.
Become familiar with all of the components that make up the Kubernetes architecture and understand its six areas of functionality.
Uncover the challenges with Kubernetes including identity and access management, network isolation, resource optimization, and patch management.