String interpolation is quick shortcut, allowing to pop up the value of a variable into double quoted String. Remember that any variable with “$” sign into single quote is not a variable, it just treat as a statement. eg. ‘$num is not a variable’ because num variable is written into single quote.

The process of deriving or making a new class from old class is known as inheritance . syntax for decleration of child or new class :- class childClassName extends ParentClassName{            statement ;    } The code is being re-used from one class to another. We need not required to re-write the same thing again and again. Extensibility is one of the advantages of the inheritance in which we can extend the base class feature without making little or no changes to fulfill the business requirements. we

php here document is another way to display the text. In this a token is use in which write multiple line without any quotes like:

Functions are used to make the programming very easy .The code is written once in the function and whenever the code is required, the function is called by its name instead of writing the whole code again. This is the benift of using function. in other word we can say, A Function is a reusable piece or block of code that performs a particular action. It takes input from the user in the form of parameters, performs certain actions, and gives

Step 1: First install to xampp server by official link https://www.apachefriends.org/download.html, after that you need to open server to start Apache server. And also start mysql for phpadmin. Step 2: Now open any browser in your pc and just type this url: http://localhost and then server run for interprete any php code. Step 3: Now create the project file and copy it’s directory and paste into the browser like: http://localhost/myphp/first.php before you create just a folder into c:\xampp\htdocs\myphp Step 4:

Kubernetes Architecture: When you deploy Kubernetes, we get a cluster. Every cluster has at least one Master node and Worker node Control Plane Components: kube-apiserver                 -> POD -> Container -> Docker image –> Google Registry etcd                                  -> POD -> Container -> Docker image –> Google Registry kube-scheduler                 -> POD -> Container -> Docker image –> Google Registry kube-controller-manager -> POD -> Container -> Docker image –> Google Registry The control plane’s components make global decisions

Pods are the smallest deployable units of computing that you can create and manage in Kubernetes. A Pod is a group of one or more containers, with shared storage and network resources, and a specification for how to run the containers. a Pod can contain init containers that run during Pod startup. a Pod is similar to a group of Docker containers with shared namespaces and shared filesystem volumes. Some Pods have init containers as well as app containers. Init containers run and complete before the app containers

Master Api server -> POD -> Container -> Docker image –> Google Registry validates and configures data for API objects, including pods and services. The API Server provides the frontend to the cluster’s shared state, which is where all of the other components interact Etcd -> POD -> Container -> Docker image –> Google Registry etcd is a distributed key-value store and the primary datastore of Kubernetes. It stores and replicates the Kubernetes cluster state. Controller mgmr -> POD ->

The Control plane (master)The Control plane is made up of the kube-api server, kube scheduler, cloud-controller-manager and kube-controller-manager. Kube proxies and kubelets live on each node, talking to the API and managing the workload of each node. As the control plane handles most of Kubernetes’ ‘decision making’, nodes which have these components running generally don’t have any user containers running – these are normally named as master nodes. Cloud-controller-managerThe cloud-controller-manager runs in the control plane as a replicated set of

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