🗼Introduction

In the world of containerization, Kubernetes has emerged as a powerful orchestrator, providing seamless management and scaling of applications. Understanding the core components of Kubernetes is essential for harnessing its full potential. In this blog, we will delve into the concepts of Pods, ReplicaSets, Deployments, and Namespaces, and explore their significance in the Kubernetes ecosystem. To illustrate these concepts, we will walk through a practical example. So, let's get started!

🗼Kubectl

kubectl is command line for K8s so that we can directly interact with the K8s cluster.

🗼Namespaces

Namespaces provide a logical separation and isolation mechanism within a Kubernetes cluster. They allow multiple teams or projects to coexist within the same cluster while maintaining resource boundaries. Namespaces help organize and manage resources by providing a scope for Pods, ReplicaSets, and Deployments. They enable fine-grained access control, resource quota enforcement, and facilitate better collaboration and management of complex deployments.
🎗️Viewing namespaces:

kubectl get namespace

🎗️Creating namespaces:

kubectl create namespace <namespace name>

🗼Pods

A Pod is the basic building block in Kubernetes, representing a single instance of a running process. It encapsulates one or more containers, storage resources, and networking configurations. Pods are ephemeral and disposable, enabling Kubernetes to easily manage application scaling, resilience, and availability. A Pod is a group of containers, with shared storage and network resources and a specification for how to run the container. A Pod is described as a definition of how to run a container. In Kubernetes, we pass the arguments and specifications to run containers in pod.yaml file. The pod is nothing but one or a group of containers.
Pod using this same image.

🎗️If we want to pass this argument in a pod we use the following syntax:

apiVersion: v1
kind: Pod
metadata:
  name: nginx
spec:
  containers:
  - name: nginx
    image: nginx:1.14.2
    ports:
    - containerPort: 80

🎗️Save this script in pod.yaml file. To create the Pod shown above, run the following command:

kubectl apply -f pod.yaml

-f Flag followed by the URL or file path

🎗️To edit you need to run the following command:

 kubectl edit pod <pod name>

kubectl replace --force -f /tmp/kubectl-edit-1690210598.yaml

Note: -kubectl replace --force -f is used for resource replacement based on a YAML file, while kubectl edit is used for interactive editing of a specific resource's configuration. Choose the appropriate command based on your use case and requirements. This will delete and create a new pod.
🎗️To get these pods run follow the command:

kubectl get pod -n <namespace>

🗼ReplicaSets

While Pods are the fundamental unit, ReplicaSets provide higher-level abstractions for managing multiple instances of Pods. A ReplicaSet ensures a desired number of replicas, or copies, of a Pod, are running at all times. It allows Kubernetes to automatically handle pod failures, scaling, and distribution across different nodes in the cluster. ReplicaSets ensure high availability and fault tolerance by constantly monitoring the state of Pods and reconciling any discrepancies.

🎗️Example:

apiVersion: apps/v1
kind: ReplicaSet
metadata:
  name: frontend
  labels:
    app: guestbook
    tier: frontend
spec:
  # modify replicas according to your case
  replicas: 3
  selector:
    matchLabels:
      tier: frontend
  template:
    metadata:
      labels:
        tier: frontend
    spec:
      containers:
      - name: php-redis
        image: gcr.io/google_samples/gb-frontend:v3

🗼Deployments

Deployments offer declarative updates for Pods and ReplicaSets. They provide a way to manage the lifecycle of applications, making it easy to roll out changes, rollbacks, and scaling. Deployments enable seamless application upgrades without any downtime by following a phased approach. They also support strategies such as blue-green deployments or canary releases, allowing controlled testing and verification of new versions before directing traffic to them.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
  labels:
    app: nginx
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:1.14.2
        ports:
        - containerPort: 80

🗼Conclusion

In this blog, we explored the fundamental concepts of Pods, ReplicaSets, Deployments, and Namespaces in Kubernetes. Pods represent individual instances of running processes, while ReplicaSets manage and maintain a desired number of Pods. Deployments enable declarative updates and control over application lifecycle, and Namespaces provide logical isolation and resource management. By understanding these core components, you can effectively leverage Kubernetes to build scalable and resilient applications.

Remember, Kubernetes is a vast ecosystem with many additional features and components beyond the scope of this blog. Continued exploration and hands-on experience will deepen your understanding of this powerful container orchestration platform. Happy orchestrating!