Kubernetes is deployment and management platforms. It offers container orchestration, a container runtime, container-centric infrastructure orchestration, load balancing, self-healing mechanisms. It is used to compose, scale, deploy, and manage application containers across host clusters.

An environment running Kubernetes consists of the following basic components: a control plane (master), a distributed key-value storage system for keeping the cluster state consistent (etcd), and cluster nodes

Kubernetes architecture components or K8s components include the Kubernetes control plane and the nodes in the cluster. The control plane or master machine components include the Kubernetes API server, Kubernetes scheduler, Kubernetes controller manager, and etcd. Kubernetes node components include a container runtime engine or docker, a Kubelet service, and a Kubernetes proxy service.

• Kubernetes API Server – The front end of the Kubernetes control plane, the API Server supports updates, scaling, and other kinds of lifecycle orchestration by providing APIs for various types of applications
• Kubernetes Scheduler – stores the resource usage data for each compute node; determines whether a cluster is healthy; and determines whether new containers should be deployed.
• Kubernetes Controller Manager – The controller watches the objects it manages in the cluster as it runs the Kubernetes core control loops. It observes them for their desired state and current state via the API server
• ETCD – key-value store database that stores configuration data and information about the state of the cluster
• Container Runtime Engine – Each compute node runs and manages container life cycles using a container runtime engine(eg – docker)
• Kubelet service – Each compute node includes a kubelet, an agent that communicates with the master or control plane to ensure the containers in a pod are running. When the control plane requires a specific action happen in a node, the kubelet receives the pod specifications through the API server and executes the action. It then ensures the associated containers are healthy and running
• Kube-proxy service – Each compute node contains a network proxy called a kube-proxy that facilitates Kubernetes networking services

What is POD?

• POD is the smallest unit in K8s
• POD cannot be created it can only be instantiated
• POD contains one or more containers
• POD represents the processes running in a cluster, through which health of the containers can be identified
• It has unique IP address
• It has persistent storage volumes
• It has configuration information that determine how a container should run
• When pods contain multiple containers, communications, and data sharing between them is simplified. Since all containers in a pod share the same network namespace, they can locate each other and communicate via localhost
• Pods are created by workload resources called controllers, which manage rollout, replication, and health of pods in the cluster. For example, if a node in the cluster fails, a controller detects that the pods on that node are unresponsive and creates replacement pod on other nodes

CMD instruction can be used to set default command to execute when we run docker container. It allows the user to execute some particular command while running docker container.

Docker file has CMD echo "This is test"
docker run -it 7de4bed89922 
This is test

docker run -it 7de4bed89922 /bin/bash
root@7de4bed89922:/#

What is the benefit of using ENTRYPOINT?

ENTRYPOINT instruction allows you to configure a container that will run as an executable. It has two forms – exec and shell

Exec form allows to set commands and parameters and then use either form of CMD to set additional parameters that are more likely to be changed. Where as shell form ignores any CMD or docker run command line arguments

Difference between CMD and ENTRYPOINT

Update command is used to update the CPU and memory configuration of the container. Available options can be checked with docker update –help command

[root@ip-172-31-7-71 centos]# docker update --help

Usage:  docker update [OPTIONS] CONTAINER [CONTAINER...]

Update configuration of one or more containers

Options:
      --blkio-weight uint16        Block IO (relative weight), between 10 and 1000, or 0 to disable (default 0)
      --cpu-period int             Limit CPU CFS (Completely Fair Scheduler) period
      --cpu-quota int              Limit CPU CFS (Completely Fair Scheduler) quota
      --cpu-rt-period int          Limit the CPU real-time period in microseconds
      --cpu-rt-runtime int         Limit the CPU real-time runtime in microseconds
  -c, --cpu-shares int             CPU shares (relative weight)
      --cpus decimal               Number of CPUs
      --cpuset-cpus string         CPUs in which to allow execution (0-3, 0,1)
      --cpuset-mems string         MEMs in which to allow execution (0-3, 0,1)
      --kernel-memory bytes        Kernel memory limit
  -m, --memory bytes               Memory limit
      --memory-reservation bytes   Memory soft limit
      --memory-swap bytes          Swap limit equal to memory plus swap: '-1' to enable unlimited swap
      --pids-limit int             Tune container pids limit (set -1 for unlimited)
      --restart string             Restart policy to apply when a container exits
[root@ip-172-31-7-71 centos]#

Example : docker update 436662ff3488 --restart always

docker wait

docker wait command waits for one or more container to exit and provides the return status of the docker exit

[root@ip-172-31-7-71 centos]# docker wait 95d0f2b4f8cf
143
[root@ip-172-31-7-71 centos]#

In the above example docker wait command gives the output when container 95d0f2b4f8cf was stopped

Return on Investment and Cost Savings
Rapid Deployment
Security
Simplicity and Faster Configurations
Continuous Integration

Disadvantages

Data in the container
There are times when a container goes down, so after that, it needs a backup and recovery strategy

Provide cross-platform compatibility
The one major issue is if an application designed to run in a Docker container on Windows, then it can’t run on Linux or vice versa

Run applications with graphical interfaces
In general, Docker is designed for hosting applications which run on the command line.

The docker pause command suspends all processes in the specified containers. When suspending a process the SIGSTOP signal is used, which is observable by the process being suspended. With container pause we cannot execute any commands which will throw an error

root@ip-172-31-7-71 centos]# docker exec b5358234e052 ls
Error response from daemon: Container b5358234e052 is paused, unpause the container before exec

Docker unpause command is used to resume the suspended container to proceed with some execution

• What is the diff between docker stop and docker kill?

Docker stop command sends the sigterm message which is short for terminate signal its a message that’s going to be received by the process telling it essentially to shut down on its own time.

Docker kill command kills signal to the primary running process inside the container. It’s like forcefully shutting down even though some task is in progress