They are the application/service

Can contain multiple containers

Pods cannot be created/destroyed, only instantiated

Pod lifecycle -> pending, ready, failed/succeeded

Pods are instantiated by Kubelet in the worker nodes

Pods can be scaled up/down

Pods have unique IPs

Containers within a Pod share namespace resources like network, mount, IPC, etc

Therefore containers within a Pod can share files and communicate with each other via localhost

Pods communicate with each other (with other pods) using the Pod network

There is a load balancer which routes traffic coming from outside to appropriate pod (with the help of kubeproxy)

Kuberenetes consists of a master, worker nodes and workstation (pc that developer uses to send commands to control plane/master)

Master has the following components:

• API Server (Communicates with every other component in the control plane aka master)
• Etcd (Cluster store -> stores information about the cluster (The desired state))
• Controller Manager (Probes all the pods in the cluster to check for their health)
• Scheduler (Schedules tasks that are to be executed by the worker nodes)

Worker has the following components:

• Kubelet (It’s a kuberenetes agent that instatiates pods in a node, works with API server)
• Container Engine (Docker/rkt)
• Kube Proxy (Works with API server to create entries in IP table -> unique IP for every pod)

These filesystems are represented as layers. Therefore each docker image has multiple filesystems, that is, each docker image has multiple layers

Each layer is identified by a uuid, which is sha256 encoded.

The lowest layer is the root filesystem. That is, it contains files under root directory

The upper most layer is the only layer which is writeable, rest all layers are readonly

Whenever you create any new files, the files are reflected in uppermost layer of the image

While mounting an image to a container, all the layers in the image are merged to create a single merged layer

The preferred storage driver for linux is overlay2. So all the layers are visible in the following location: /var/lib/docker/overlay2

You can see the layers your docker image has by looking in the “RootFS” header when you do “docker inspect imagename”

The files that you add, which are added to the uppermost layer get added to two locations /var/lib/docker/<layer-uuid>/merged and /var/lib/docker/<layer-uuid>/diff

It is possible to create a container by selectively removing the top few layers of an image. This can be done to undo the changes that have been made in a layer.

docker inspect <image-name>