In this article, we will learn about the basic objects of Kubernetes in detail with their respective YAML files.

• POD
• Replication Controller
• Replica Set
• Daemon Set
• Deployment
• Service
• Volume
• Job

POD

A pod is a basic unit of K8S. Pod always run on node. In K8S cluster Pod represents running process. Inside the pod, you can have one or, more containers. Those containers all share a unique Network IP, storage, network and any other specification applies to the pod. Pods abstract network and storage away from the underlying container. This lets you move containers around the cluster more easily. Each pod has its own unique ip address within the cluster.

Any data saved inside the pod will disappear without a persistent storage.

Note : For better understanding, let’s consider an NGINX Image for all the YAML files as an example.

YAML for POD:

apiVersion: v1
kind: Pod
metadata:
    name: 1stPOD                                                    
    labels:
    app: nginx                                                            
    spec:
      containers:
      - name: 1stContainer
        image: nginx
        ports:
        - containerPort: 80

PODs are ephemeral (lasts for a very short time) and won’t be rescheduled to a new node once it dies.

Make sure that a pod is not used directly for deployment, because Kubernetes has controllers such as Replica Sets, Deployment, Daemon Sets which keep the pods alive.

Replication Controller

Replication controller is one of the key features of Kubernetes which manages the lifecycle of a Pod. It is responsible for creating multiple pods and ensure that the specified number of pod replicas are always present and running at any point of time.

YAML for Replication Controller

apiVersion: v1
kind: ReplicationControlller
metadata:
  name: 1stRC-Pod
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: 1st RC-Container
        image: nginx
        imagePullPolicy: Always
        ports:
        - containerPort: 80

Replica Set

Replica Set is the next-generation Replication Controller. The only difference between a Replica Set and Replication Controller is the selector support.

Replica Set supports the new set-based selector approach whereas Replication Controller uses equality-based selector requirements.

YAML for Replica Set

apiVersion: apps/v1
kind: ReplicaSet
metadata:
  name: my-rs-pod
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx-rs-pod
    matchExpressions:
-	Key: env
Operator: In
values:
-dev
  template:
    metadata:
      labels:
        env: dev
        app: nginx-rs-pod 
    spec:
      containers:
      - name: 1stRS-container
        image: nginx
        ports:
            containerPorts: 80

Daemon Set

A daemon Set ensures that all or some of the Kubernetes nodes run a copy of the pod.

When a new node is added to the cluster, a Pod is added to it match the rest of the nodes and when a node is removed from the cluster, the pod is garbage collected.

YAML for Daemon Set:

apiVersion: apps/v1
kind: DaemonSet
metadata:
  name: my-Ds-pod
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx-ds-pod
  template:
    metadata:
      labels:
        app: nginx-ds-pod 
    spec:
      nodeSelector:
         name: node1    #labled the node; kubectl label nodes  =
      containers:       
      - name: 1stDS-container
        image: nginx
        ports:
            containerPorts: 80

Deployment

In Kubernetes, using a deployment is the recommended way to deploy a pod or ReplicaSet because of the advanced features it comes with.

Below are the some of the key benefits of using Deployment:

• Update pods
• Rollback to previous versions
• Scale deployment up or down
• Pause and resume the deployment
• Use the status of deployment to determine state of replicas
• Clean up older RS that you don’t need anymore.

Deployment has two strategies

Recreate strategy: In this type of very simple deployment, all the old pods are killed at once and they are replaced all at once with the new pods.

YAML for Recreate type:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-Deployment-pod
spec:
  replicas: 3
  selector:
  strategy:
  type: Recreate
    matchLabels:
      app: nginx-deployment-pod
  template:
    metadata:
      labels:
        app: nginx-deployment-pod 
    spec:
       containers:       
       - name: 1stdeployment-container
          image: nginx:1.7.9
            ports:
               containerPorts: 80

Rolling Update strategy: The rolling update is the standard default deployment for Kubernetes. It works slowly, replacing pods in the previous version of your application with the new version without any cluster downtime

YAML for Rolling Update:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: 1st-deployment-Ru-pod
  labels:
    app: nginx
spec:
strategy:
  type: Rollingupdate
 rollingupdate:
    maxSurge: 1
    maxUnavailable: 1
minReadySeconds: 30
  replicas: 2
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: 1stdeployment-RU-Conatiner
        image: nginx:1.7.9
        ports:
        - containerPort: 80