What is Kubernetes?
Kubernetes (K8s) is an open-source container orchestration platform designed to automate the deployment, scaling, and management of containerized applications. It was originally developed by Google and is now maintained by the Cloud Native Computing Foundation (CNCF). Kubernetes provides a robust and flexible infrastructure for running applications in a highly scalable and fault-tolerant manner.
Why We need Kubernetes?
Kubernetes is a powerful and popular open-source container orchestration platform that is widely used in the world of modern software development and deployment. It addresses several critical challenges that arise when managing containerized applications at scale. Here are some reasons why we need Kubernetes:
Automated Deployment and Scaling
Container Orchestration
Load Balancing and Service Discovery
Rolling Updates and Rollbacks
Declarative Configuration:
How Kubernetes works?
Kubernetes works as a distributed system that manages containerized applications across a cluster of nodes (servers). It follows a master-worker architecture, with the master being responsible for overall cluster management and the workers (also called nodes) running the actual containers. Here's an overview of how Kubernetes works:
Nodes (Workers): A node is a physical or virtual machine that runs containers. Each node has a Kubernetes agent called "kubelet" that communicates with the master and ensures that containers are running as expected on the node. Nodes also have a container runtime (e.g., Docker, containerd) responsible for pulling and running container images.
Master: The master is the control plane of Kubernetes, responsible for managing the entire cluster. It consists of several components:
API Server: It serves as the frontend to the Kubernetes control plane. It validates and processes RESTful API requests, manages the state of all objects in the cluster (e.g., pods, services, deployments), and communicates with the etcd datastore.
etcd: It is a distributed key-value store that stores the cluster's configuration data, representing the desired state of the cluster. The API server reads from and writes to etcd to maintain the current state of the cluster.
Controller Manager: It runs various controllers responsible for maintaining the desired state of the cluster. For example, the ReplicaSet controller ensures the specified number of replicas of a pod is running, and the Deployment controller manages updates and rollbacks of application deployments.
Scheduler: The scheduler is responsible for placing pods onto nodes based on resource requirements, node capacity, and other constraints. It helps balance workloads across the cluster.
Pods: A pod is the smallest deployable unit in Kubernetes. It represents one or more tightly coupled containers sharing network and storage namespaces. Containers within a pod can communicate with each other using localhost, making it easier to design and deploy multi-container applications.
ReplicaSets and Deployments: ReplicaSets are responsible for ensuring a specified number of replicas (identical pods) are running in the cluster. Deployments build on top of ReplicaSets and allow declarative updates and rollbacks of applications. When you update a Deployment, it creates a new ReplicaSet with the updated version and gradually scales it up while scaling down the old version.
Services: A Service is an abstraction that defines a stable endpoint (IP address and port) to access one or more pods. It provides load balancing across multiple pods, ensuring high availability and easy service discovery.
Ingress: An Ingress is a resource that manages external access to services within the cluster. It allows you to define routing rules and SSL termination for incoming traffic.
ConfigMaps and Secrets: ConfigMaps hold configuration data as key-value pairs, which can be consumed by pods as environment variables or mounted as volumes. Secrets are similar but specifically designed to store sensitive data, like passwords or API keys, in an encrypted format.
What is Pods?
In Kubernetes, a pod is the smallest and simplest deployable unit that represents a single instance of a running process in a cluster. It is the fundamental building block for deploying containerized applications. A pod encapsulates one or more tightly coupled containers, storage resources, a unique network IP, and options for how to run the containers.
A Kubernetes pod is a collection of one or more Linux containers, and is the smallest unit of a Kubernetes application. Any given pod can be composed of multiple, tightly coupled containers (an advanced use case) or just a single container (a more common use case). Containers are grouped into Kubernetes pods in order to increase the intelligence of resource sharing
Top comments (0)