Kubernetes is a platform for managing a multi- container based deployment for distributed workloads for APP and services,

Why Do we need Kubernetes?

Main rational is to to achieve scalability and load balancing and fault tolerance by ensuring availability of all distributed nodes of application.

It is more portable and extensible such that it would also speeds up the delivery process and provides better resource management.

This concept would also be easily adoptable for cloud based deployments.

Benefits of Kubernetes?

1. Easily extensible and portable
2. Open source and better support in its eco system
3. Easily Adoptable for Cloud based deployments.
4. Self monitoring and container balancing
5. Support Nodes for both Windows and Linux

How Kubernetes works aka Kubernetes architecture with image

Kubernetes overall architecture is a cluster of worker Nodes (aka Kube Minions) that are managed and controlled by groups of Masters called Kubemasters.

Nodes run containerized applications or Services. Every cluster can have minimum one worker node to many nodes.

The worker nodes host the logical components called Pods and each Pod would contain group of one or more containers. The Controller on Kube-master manages the worker nodes and the Pods in the cluster. In production environments, the control plane usually runs across multiple computers and a cluster usually runs multiple nodes, providing fault-tolerance and high availability.

In case of any Worker Node is down, the controller automatically load balances by starting that pod in other Node.

Master doesn’t start and initialize the node on its own. At Node side Kubelet would hold responsibility of starting pods and then sends registration requests to Kube Masters.

What is POD?

A pod is logical unit that encapsulates one or more Containers (Can be Docker or Rkt)

Pods are atomic by nature. They shared resources like Storage, Network etc. across container.

Once Pod is created, it would not be reused for another creating instance. We may recreate similar pod based on need.

On the same note PODs are actually gets instantiated as atomic instance. Once Pod gets initialized it would be kept in pending state until container gets started. Then it would go into Running state and finally after Container’s job is done it would go to Terminate state with either Success or Failure.

if a pod (or the node it executes on) fails, Kubernetes can automatically create a new replica of that pod to continue operations.

Container:

1. Container in short a runtime of it’s own
2. Runs in separate namespace isolated from host
3. Has its own Root FS & USER space, PID tree, MNT and Network etc.
4. This is not a bootable image like VM and BOOT FS is held with host itself.
5. Its own quota of Resources like RAM, CPU etc would be Allocated through cgroups

Docker:

1. Container manager SW that run on host OS
2. Runs as daemon server and can orchestrate more than one container.
3. would run in its own user group called “docker” and We can add Non-root users to docker group to run and manage containers and ensure security without needing rely on Admin/root users.
4. provides complete set of toolkit to manage and tune containers

• docker pause would just suspend current running processes in one or more container by saving their state and keeping Memory print still active.
• When we unpause it would being back all suspended processes back to runtime by attaching the same memory and process state as before pause.

• docker stop would gracefully terminate all running process by sending SIGTERM signal
• docker kill do abrupt shutdown processes by sending SIGKILL signal