Kubernetes, also known as K8s, was built by Google. It is now an open-source project and is arguably one of the best and most popular container orchestration technologies available.
What are containers?
Containers are completely isolated environments, meaning they can have their own processes or services, their own network interfaces, and their own mounts, just like virtual machines, except that all containers share the same operating system kernel.
We can simply say that a container is like a software unit or wrapper that packages everything — your application code, app-related dependencies, and so on — together.
Why Kubernetes?
Imagine you need to run 10 separate applications (microservices) at once. To do that, you need about 10 containers that hold each application’s files and tools. Now, to make sure each applications runs smoothly, you might create 2 copies of each container, making 20 containers in total. Managing all 20 containers can be a lot of work!
Container Orchestration
A container orchestration tool or framework can help you in these situations. This whole process of automatically deploying and managing containers is known as Container Orchestration.
Orchestration Technologies
1.Docker Swarm — from Docker — Really easy to setup and get started with, but it lacks some of the advanced autoscaling features required for complex applications.
2.Kubernetes— from Google — Arguably the most popular of it all — is a bit difficult to setup and get started with, but provides a lot of options to customize deployments and supports deployment of complex architectures.
3.MESOS — from Apache — Quite difficult to setup and get started with, but supports many advanced features.
What is Kubernetes?
Kubernetes is an open-source container orchestration platform designed to automate the deployment, scaling, and management of containerized applications across a cluster of hosts.
It provides a set of abstractions and APIs for managing containers, allowing you to focus on building your application without worrying about the underlying infrastructure.
With Kubernetes, you can manage multiple containers across multiple machines. This simplifies and automates the deployment and management of your application infrastructure.
Kubernetes is now supported on all public cloud service providers like GCP, Azure and AWS.
Terminology
Let’s explore the common terminology used in Kubernetes.
Nodes(Minions)
A node is a machine, either physical or virtual, where Kubernetes is installed. Nodes act as worker machines and are where Kubernetes launches containers.
Cluster
A cluster is a set of nodes grouped together. This ensures that your application remains accessible even if one node fails. Multiple nodes also help to distribute the load, which improves performance.
Master
The master node is another node with Kubernetes installed on it. It is configured as a master and watches over the nodes in the cluster. The master node is responsible for orchestrating containers on the worker nodes.
Components
When you install Kubernetes on a System, you are actually installing the following components.
An API Server
An etcd service
A kubelet service
A Container Runtime
Controllers
Schedulers
The API server acts as the frontend for Kubernetes. Users, management devices, and command-line interfaces all communicate with the API server to interact with the Kubernetes cluster. etcd is a distributed, reliable key-value store used by Kubernetes to store all data used to manage the cluster. Think of it this way: when you have multiple nodes and multiple masters in your cluster, etcd stores all that information on all the nodes in the cluster in a distributed manner. etcd is responsible for implementing locks within the cluster to ensure there are no conflicts between the masters.
The scheduler is responsible for distributing work or containers across multiple nodes. It looks for newly created containers and assigns them to nodes. The Controllers are the brains behind orchestration. They are responsible for noticing and responding when nodes, containers, or endpoints go down. The controllers make decisions to bring up new containers in such cases.
The Container Runtime is the underlying software used to run containers (e.g., Docker). Finally, kubelet is the agent that runs on each node in the cluster. The agent is responsible for ensuring that the containers are running on the nodes as expected.
Kubernetes Architecture
Control Plane: This is the brain of the Kubernetes cluster and manages the overall state of the system. It includes API Server, etcd, Controller Manager, and Scheduler.
kube-proxy: This component manages network routing for services within the cluster.
pod: A pod is the smallest deployable unit in Kubernetes. It represents a single instance of a running process and can contain one or more containers.
ReplicaSet: This ensures that a specified number of replicas of a pod are running at all times. It automatically scales the replicas based on demand.
Deployment: A higher-level object that manages ReplicaSets and provides declarative updates to the pods and ReplicaSets in the cluster.
ConfigMap: This configuration store holds configuration data in key-value pairs and provides a convenient way to manage configuration data for applications.
Secret: A secure way to store and manage sensitive information such as passwords, API keys, and certificates.
Volume: This directory is accessible to all containers running in a pod. Volumes can be used to store data or share files between containers.
Conclusion
Imagine Kubernetes as a classical ‘Master–Worker’ cluster setup. The Master node has the responsibility to perform absolutely necessary processes to run/manage the cluster, while the Worker nodes actually run your applications.
In essence, you instruct Kubernetes about the application’s desired state, and then it is Kubernetes’ responsibility to achieve and maintain that state. To provide instructions, you need to use YAML or JSON manifest/config files.
