virtual entity. Can not be started. Only can be instantiated K8 manages pods Pods have unique IP in that particular cluster Pods can have multiple container ( not same image) in a single pod Pods talk with other pods using pod network which is provided by kubeproxy pods are atomic ( either ready or pending ) they are unique in a cluster they are in life cycle : pending–> running–>success or fail at the exit pods are used in master

What is the architecture and components of Kubernetes? 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

What is the architecture and components of Kubernetes? Kubernetes is a portable, extensible, open-source platform for managing containerized workloads and services, that facilitates both declarative configuration and automation. It has a large, rapidly growing ecosystem. Kubernetes services, support, and tools are widely available. When you deploy Kubernetes, you get a cluster. A Kubernetes cluster consists of a set of worker machines, called nodes, that run containerized applications. Every cluster has at least one worker node. The worker node(s) host the Pods that are

Pods are the smallest, most basic deployable object State of the pod is pending, running, succeeded / failed Pods are instantiated Pods contains one or more containers pods are part of nodes each pod has unique IP address pod is created in node typically, same service / app containers are not deployed in same pod (port has to be unique) Pods are like minions. Pods is virtual or logical concept… pods cannot be accessed directly. network parameters within a pod are

kube-apiserver kubernetes API server validates and configures data for the api objects which include pods, services, replications controllers and others. This is the only component that communicates with the etcd cluster, making sure data is stored in etcd and is in agreement with the service details of the deployed pods kube-controller It runs number of distinct controller processes in the background( replication controller controls number of replicas in a pod). And it will regulate the shared state of the cluster

Atomic unit of work in Kubernetes 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

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:

Master Node: Api serverCluster StoreSchedularController managerkubeletdockerkube proxykubectlkubeadm Worker Node: kubeletdockerkube proxykubectlkubeadm Workstation: kubectl

master / Control plane Master – Api server -> POD -> Container -> Docker image –> Google Registry – Etcd -> POD -> Container -> Docker image –> Google Registry – Controller mgmr -> POD -> Container -> Docker image –> Google Registry – Schedular -> POD -> Container -> Docker image –> Google Registry – kubelet – docker – kube proxy -> POD -> Container -> Docker image –> Google Registry – kubectl – kubeadm Worker – kubelet –

Constructor is a method (FUNCTIONJ) defined inside a class is called automatically at the time of creation of object. Main aim of a constructor method is to initialize the object. In PHP, a method of special name __construct acts as a constructor. There are two type of constructor in PHP Default constructor 2. Parameterized constructor Default constructor In default constructor ther are no parameter passed during the creation of constructor. eg:- Parameterized constructor In parameterized constructor the are one or more than

The basic concepts of Object-oriented programming concepts are: Class Object Inheritance Constructor Destructor Polymorphism CLASS A class is a template which represents a real-world entity, and it defines properties and methods of the entity. It is only structure of operations , it comes in action when object is being created You could think of class properties as variables that are used to hold information about the object. Object Objects are an instance of a class. A variable holds the data

What is the benefit of using CMD? 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. 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

Title – Complete referenece of dockerfile cmd and entrypoint What is the benefit of using CMD? What is the benefit of using ENTRYPOINT? Compare CMD vs Entrypoint with 5 Bullets points in tablular format What happens When i specify 2 CMD in one dockerfile? What happens When i specify 2 ENTRYPOINT in one dockerfile? What happens When i specify 1 ENTRYPOINT & 1 CMD in one dockerfile? What is the differenece between exec mode and shell mode? Run these 5

Docker image image is the collection of file systems.Each file system in image is known as layer.Docker image can contain either single layer or multiple layers.In case of multiple layes one layer is originated from prev layer.Base file system(root) is the mandatory layer of the image.One copy of image can mounted into each container.All layers are meged into one layer before mounted to container.Highest layered file gets priority to avoid conflicts at the time of merging.Repo name can always same

It’s a collection of filesystems, namely => rootfs, user fs, application fs 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

Define a docker image in points Docker Image has many layers which holds the information required for the configuration. Base image + parent image + layers+ container layer + docker manifest. Each of the files that make up a Docker image is known as a layer. These layers form a series of intermediate images, built one on top of the other in stages, where each layer is dependent on the layer immediately below it. Thus, you should organize layers that change most often