What is Kubernetes?
Kubernetes is a DevOps tool for containerization. As an open source tool, the Kubernetes container orchestration tool manages the provision, scaling and administration of containerized applications.
This makes the Kubernetes tools indispensable DevOps tools for the cloud.
Kubernetes – Container orchestration with Kubernetes container tools
How does Kubernetes work?
Kubernetes manages container units in clusters, with the node concept playing a central role in the clustering of container applications:
Nodes – the smallest unit in the Kubernetes cluster
In Kubernetes, a node is the smallest unit of computer hardware represented in the cluster. The node, whether it is a physical machine or a VM, is abstracted into a set of CPU and RAM resources that can be used. There are two different types of nodes that make up the Kubernetes cluster .
Worker nodes
The worker node, referred to simply as a node in the terminology, is the location where the containerized applications are executed.
Master node
The master node, also known as the control plane is the one that manages the state of the cluster. Together they form a master-slave architecture.
Kubernetes pods
Containerized applications are packaged in higher-level objects, so-called pods.
A pod can encapsulate multiple containers to share compute, storage and network resources. The pods act as units of replication and can therefore be scaled by deploying new replicas. However, pods scale as units and not as individual containers and should therefore only contain tightly coupled containers.
Ephemeral Container – The ephemeral nature of containerized applications
Pods are mortal and should be considered volatile , meaning they can be terminated unexpectedly and redeployed on another node. Rolling updates can be performed on pods without downtime . This is achieved by incrementally updating each pod and scheduling the new pods on available nodes.
Deployments as superordinate architecture layers of the container deployments
Pods are usually managed by a higher-level abstraction called deployments to enable self-healing, scalability, rolling updates and rollbacks.
YAML configuration of container applications
A deployment is defined as a YAML configuration file that describes how to handle the pod. The deployment uses ReplicaSets to ensure self-healing and scaling of the pods. For example, if a pod managed by a deployment fails, it is replaced by a new one, and if the load increases, more pods can be deployed to handle the load.
Kubernetes pods and dynamic IP addresses
Pods have their own dynamic IP address, but this cannot be relied upon due to its volatility and is not disclosed outside the cluster.
API service objects of Kubernetes clusters
Kubernetes provides API service objects, which are an abstraction with logical information to communicate with a set of pods in the cluster.
There are different ways to define a service:
ClusterIP
The ClusterIP shows the service internally in the cluster with an IP address.
NodePort
The NodePort makes the service available on all nodes with a specific port, which forwards all data traffic to the automatically created cluster IP. The NodePort service can also be accessible outside the cluster.
Load balancer
The LoadBalancer provides the service with the load balancer of a cloud provider. NodePort and ClusterIP are created automatically, to which the load balancer then forwards the traffic.
Kubernetes & Ingress
Ingress is another object to provide a service outside the cluster with load balancing and SSL termination. The ingress controller is responsible for fulfilling the ingress configuration and there are many different controllers to achieve this.
Ingress works by providing a URL to forward external HTTP or HTTPS requests to services within the cluster.
Kubernetes auto-scaling functions
Kubernetes offers multiple levels of autoscaling features such as Horizontal Pod Autoscaler (HPA), Vertical Pod Autoscaler (VPA) and Cluster Autoscaler (CA).
Horizontal Pod Autoscaler (HPA)
The Horizontal Pod Autoscaler automatically scales the number of ReplicaSets in a deployment based on metrics such as CPU, memory, or other user-defined metrics. HPA is implemented as a controller that periodically polls the specified resource utilization using the metric specified by the Metrics API, called the Metrics Server.
The target value of the metric is then compared to the queried utilization value as a percentage in each container in the pods. The controller takes the average of the determined value across all pods and creates a ratio to scale the number of pods.
Kubernetes only provides CPU and memory as default metrics. To scale using a custom metric value provided by the application, another supported metric server must be installed and configured.
Vertical Pod Autoscaler (VPA)
The Vertical Pod Autoscaler allocates more or less CPU and memory resources to existing pods. The metric value can be initialized when the pod is created or monitored and scaled during the pod’s lifetime.
The VPA does not change the available resources of the running pods. Instead, it checks whether the managed pods have the correct resources, and if not, it terminates the pod. The pods are then rescheduled on available nodes with the newly set resources.
Cluster autoscaler (CA)
Cluster Autoscaler scales the number of nodes in the cluster based on the total number of pending pods. It checks how many pending pods are available and adds new nodes to the cluster to enable the deployment of these pending pods. CA also deallocates unused nodes to optimize the cluster size. This feature can be easily integrated into the cluster through interfaces to cloud providers.
What does the Kubernetes architecture look like?
The Kubernetes architecture consists of flexible and loosely coupled components that make up the cluster. Normally, a Kubernetes cluster consists of at least one master and several worker nodes.
Master Node
The master node is responsible for providing the API, planning deployments and detecting and responding to events in the cluster. The master is also known as the control plane and consists of the following main components.
kube API server
The API server is the central component that exposes the Kubernetes API. Every component in Kubernetes communicates with the server via a REST request. The API server is responsible for authentication and authorization to verify the legitimacy of the request.
The API server also implements a monitoring mechanism so that other components can interact with it.
Etcd
Etcd is a key-value store that is used to store the configuration data of the Kubernetes cluster. This means that it stores the essential information about the Kubernetes objects, such as running nodes and pods. Etcd can be used to configure a backup plan to restore the cluster in the event of a failure.
Kube Controller Manager
The Kubernetes controller manager monitors the state of the cluster via the watch function on the API server. If an event occurs, the controller is notified and makes the necessary changes to transform the current state into the desired state.
Kube-Scheduler
The kube-scheduler waits for schedule events and schedules pods on healthy nodes. Each pod that the scheduler detects performs a calculation to find the best node depending on the pod’s required resources and QoS requirements.
Working node
Each cluster has at least one working node, but usually several. Each worker node hosts scheduled pods and controls all running application workloads. The worker node provides Kubernetes runtime environments and communicates with the master node to ensure the desired state of the running pods. Each worker node consists of the following main components.
Cubelet
The kubelet is an agent that is responsible for ensuring that the containers are executed on the node as expected. It communicates with the master node to receive the work tasks and sends information about the status of the running containers.
Kube proxy
The Kube proxy is a component that enables communication between pods and services. It helps to forward the request and performs load balancing for healthy pods.
The most common proxy mode is iptables. Iptables mode watches the master for added or removed service objects and applies iptables rules to intercept traffic to the virtual service IP address and forward it to a random pod.
There are other proxy modes such as userspace and IPVS, each with different implementations and load balancing algorithms.
Container runtime
Each node requires a container runtime in order to execute containers in this operating environment. Kubernetes is very often used with Docker as a container runtime environment , but also supports other OCI runtimes.
Why is Kubernetes so popular?
Kubernetes is the most popular container orchestration tool used in a production environment today, according to a recent Cloud Native Computing Foundation (CNCF) survey.
But why exactly is Kubernetes so popular? The answer lies in its flexibility, scalability and comprehensive functionality, which enables developers and companies to manage modern applications efficiently.
1. scalability and automation
Kubernetes offers automatic scaling of containers, both horizontally and vertically. Companies can efficiently distribute workloads and spin up new instances on demand, which is particularly important in dynamic environments and for large applications with fluctuating traffic. The ability to automatically optimize resources saves costs and improves performance.
2. platform independence
One of the biggest advantages of Kubernetes is its platform independence. It works on all common cloud providers such as AWS, Google Cloud and Microsoft Azure as well as in on-premises environments. This allows companies to design their infrastructure flexibly without being tied to a specific provider. This interoperability significantly reduces the risk of vendor lock-in.
3. modularity and expandability
Kubernetes has a modular structure and offers developers the opportunity to customize their infrastructure with a variety of extensions and plugins. Thanks to the open ecosystem, tools such as Istio for service meshes or Helm for package management can be easily integrated. This makes Kubernetes the ideal platform for complex, microservice-based architectures.
4. community and open source
Strong support from a global open source community makes Kubernetes a constantly growing and improving technology. The community regularly contributes new features, security updates and integrations, which not only keeps Kubernetes innovative, but also stable and reliable in the long term.
5. standardization and future-proofing
Through its widespread adoption, Kubernetes has de facto set the standard for container orchestration. Companies that use Kubernetes are investing in a technology that is highly likely to remain relevant in the future. This makes Kubernetes a safe choice for companies looking to invest in modern and future-proof IT infrastructures.
6. seamless integration with DevOps
Kubernetes is perfectly aligned with modern DevOps practices. It facilitates the introduction of Continuous Integration/Continuous Deployment (CI/CD) pipelines and automates the entire software lifecycle. This enables development teams to work faster, implement releases more efficiently and increase the quality of their applications.
7. management of complex applications
Kubernetes enables companies to manage highly complex applications with many services and dependencies. Functions such as self-healing (automatic restarts of faulty containers), rolling updates and canary deployments make Kubernetes an indispensable tool for managing modern applications.
Conclusion: Kubernetes as a game changer
The popularity of Kubernetes is no coincidence. Its robust architecture, broad support and future-proof orientation make it an indispensable part of modern software development. Companies that use Kubernetes benefit from increased efficiency, cost savings and a scalable infrastructure that can keep pace with the requirements of growing applications.
Rock the Prototype Podcast
The Rock the Prototype Podcast and the Rock the Prototype YouTube channel are the perfect place to go if you want to delve deeper into the world of web development, prototyping and technology.
🎧 Listen on Spotify: 👉 Spotify Podcast: https://bit.ly/41pm8rL
🍎 Enjoy on Apple Podcasts: 👉 https://bit.ly/4aiQf8t
In the podcast, you can expect exciting discussions and valuable insights into current trends, tools and best practices – ideal for staying on the ball and gaining fresh perspectives for your own projects. On the YouTube channel, you’ll find practical tutorials and step-by-step instructions that clearly explain technical concepts and help you get straight into implementation.
Rock the Prototype YouTube Channel
🚀 Rock the Prototype is 👉 Your format for exciting topics such as software development, prototyping, software architecture, cloud, DevOps & much more.
📺 👋 Rock the Prototype YouTube Channel 👈 👀
✅ Software development & prototyping
✅ Learning to program
✅ Understanding software architecture
✅ Agile teamwork
✅ Test prototypes together
THINK PROTOTYPING – PROTOTYPE DESIGN – PROGRAM & GET STARTED – JOIN IN NOW!
Why is it worth checking back regularly?
Both formats complement each other perfectly: in the podcast, you can learn new things in a relaxed way and get inspiring food for thought, while on YouTube you can see what you have learned directly in action and receive valuable tips for practical application.
Whether you’re just starting out in software development or are passionate about prototyping, UX design or IT security. We offer you new technology trends that are really relevant – and with the Rock the Prototype format, you’ll always find relevant content to expand your knowledge and take your skills to the next level!
