A Pod (as in a pod of whales or pea pod) is a group of one or more containers, with shared storage and network resources, and a specification for how to run the containers. 

Pods can communicate with each other by using another pods IP address or by referencing a resource that resides in another pod.

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(s) on other nodes.

pods simplify scalability, enabling replica pods to be created and shut down automatically based on changes in demand.

Each Pod is meant to run a single instance of a given application. If you want to scale your application horizontally (to provide more overall resources by running more instances), you should use multiple Pods, one for each instance. In Kubernetes, this is typically referred to as replication.

The shared context of a Pod is a set of Linux namespaces, cgroups, and potentially other facets of isolation – the same things that isolate a Docker container. Within a Pod’s context, the individual applications may have further sub-isolations applied.

When a pod is created it is assigned its own unique IP address. If there are multiple containers within the pod, they can communicate between each other simply by using localhost.

Communications outside of the pod is achieved by exposing a port. Communications between pods in a cluster takes advantage of the fact that Kubernetes assigns a cluster-private IP address to every pid in a cluster, eliminating the need to either explicitly create links between pods or to map container ports to host ports. 

Once created, a Pod remains on its node until its process is complete, the Pod is deleted, the Pod is evicted from the node due to lack of resources, or the node fails. If a node fails, Pods on the node are automatically scheduled for deletion.

kubelet

An agent that runs on each node in the cluster. It makes sure that containers are running in a Pod.The kubelet takes a set of PodSpecs that are provided through various mechanisms and ensures that the containers described in those PodSpecs are running and healthy. The kubelet doesn’t manage containers which were not created by Kubernetes

kube-proxy

kube-proxy is a network proxy that runs on each node in your cluster, implementing part of the Kubernetes Service concept.

Container runtime

The container runtime is the software that is responsible for running containers

API Server

Kubernetes is an API server which provides all the operation on cluster using the API. 

Controller Manager

This component is responsible for most of the collectors that regulates the state of cluster and performs a task and is responsible for collecting and sending information to API server.

Scheduler

This is one of the key components of Kubernetes master. It is a service in master responsible for distributing the workload. It is responsible for tracking utilization of working load on cluster nodes and then placing the workload on which resources are available and accept the workload.

1. Pod — collection of containers

3.Scaling

4.Provides additional services: as well as the management of containers, Kubernetes offers security, networking and storage services

5.Storage orchestration: Kubernetes mounts and add storage system of your choice to run apps

6.Container balancing: Kubernetes always knows where to place containers, by calculating the “best location” for them

root@ip-172-31-28-155:/home/ubuntu/srm# docker run -it image_multi
Hello Entry kannan /bin/sh -c echo “Hello CMD kp”

root@ip-172-31-28-155:/home/ubuntu/srm# cat dockerfile_multi
FROM ubuntu
MAINTAINER Rajesh Kumar << rajesh@scmgalaxy.com>>
ENV DEBIAN_FRONTEND=noninteractive
RUN apt-get update
RUN apt-get -y install tzdata
RUN apt-get install git -y && apt-get install -yq apache2
CMD echo “Hello CMD kp”
CMD echo “Hello CMD kannan”

root@ip-172-31-28-155:/home/ubuntu/srm# docker run -it image_multi
Hello CMD kannan

root@ip-172-31-28-155:/home/ubuntu/srm# cat dockerfile_multi
FROM ubuntu
MAINTAINER Rajesh Kumar << rajesh@scmgalaxy.com>>
ENV DEBIAN_FRONTEND=noninteractive
RUN apt-get update
RUN apt-get -y install tzdata
RUN apt-get install git -y && apt-get install -yq apache2
ENTRYPOINT [“/bin/echo”, “Hello Entry k”]
ENTRYPOINT [“/bin/echo”, “Hello Entry kp”]

root@ip-172-31-28-155:/home/ubuntu/srm# docker run -it image_multi
Hello Entry kp

MAINTAINER : Author of docker file

RUN : Run the commands in new layer

VAR : Used to set variable, we can re-use these variables later

EXPOSE : specify port of the container

COPY : Copy files to the container

ADD : copy files into container and extract it

USER : Set the runtime user

ENV : set environment variable

CMD : to set PID1

ENTRY POINT : to set PID1

WORK DIR : set the working directory

Update a container’s cpu-shares
$ docker update --cpu-shares 512 1afa20d7cfe5

Docker container with image is an executable software package built on top of its own root file system. Every docker image will have its own docker container.

Q2. What is the difference between docker stop and docker kill?

‘stop’ commands does graceful shutdown….where ‘kill’ command does a forceful kill. The status code will be different for both eventhough the status is same (Exited)

after stop command, exit code is 0

  2  docker create --name kannan httpd
    3  docker ps -a
    4  docker start kannan
    5  docker stop kannan
    6  docker ps -a
    7  docker start kannan
    8  docker kill  kannan
    9  docker ps -a
   10  history

Q3. What is the difference between docker pause and docker unpause?

after pause command (docker pause kannan)

Using pause command we can suspend the container for some time and we can resume it later

 11  docker start kannan
   12  docker pause kannan
   13  docker ps -a
   14  docker unpause kannan
   15  docker ps -a