Kubernetes

Kubernetes Terminology,
Kubernetes Features ,Kubernetes Pods, Kubernetes Cluster Model

,
 Kubernetes
• Kubernetes in an open source container management
tool hosted by Cloud Native Computing Foundation
(CNCF). This is also known as the enhanced version of
Borg which was developed at Google to manage both
long running processes and batch jobs, which was
earlier handled by separate systems. Kubernetes
comes with a capability of automating deployment,
scaling of application, and operations of application
containers across clusters. It is capable of creating
container centric infrastructure.
 Following are some of the important
features of Kubernetes

• Continues development, integration and deployment

• Containerized infrastructure
• Application-centric management
• Auto-scalable infrastructure
• Environment consistency across development testing and
production
• Loosely coupled infrastructure, where each component can
act as a separate unit .
• Higher density of resource utilization
• Predictable infrastructure which is going to be created
• One of the key components of Kubernetes is,
it can run application on clusters of physical
and virtual machine infrastructure. It also has
the capability to run applications on cloud. It
helps in moving from host-centric
infrastructure to container-centric
infrastructure.
 Kubernetes ─ Architecture
• As seen in the following diagram, Kubernetes
follows client-server architecture. Wherein,
we have master installed on one machine and
the node on separate Linux machines.
• Kubernetes uses a cluster architecture. A Kubernetes
cluster comprises many control planes and one or more
physical or virtual machines called “worker nodes.” The
worker nodes host Pods, which contain one or more
containers.
• A container is a runtime environment containing a
software package and all its dependencies. Container
images are standalone collections of the executable
code and content that are used to populate a container
environment as illustrated in the following figure:
 Kubernetes terminology

• The control plane makes decisions about the cluster. This

includes scheduling containers to run,
detecting/responding to failures, and starting new Pods
when the number of replicas listed in a Deployment file is
unsatisfied. The following logical components are all part
of the control plane
• Controller manager – Monitors the Kubernetes cluster to
detect and maintain several aspects of the Kubernetes
environment including joining Pods to services,
maintaining the correct number of Pods in a set, and
responding to the loss of nodes
•  Cloud controller manager – An optional component used for cloud-based
deployments. The cloud controller interfaces with the cloud service provider
(CSP) to manage load balancers and virtual networking for the cluster.

• Kubernetes application programming interface (API) server – The interface

through which administrators direct Kubernetes. As such, the API server is
typically exposed outside of the control plane. It is designed to scale and may
exist on multiple control plane nodes.
• Etcd® – The persistent backing store where all information regarding the state
of the cluster is kept. Etcd is not intended to be manipulated directly but
should be managed through the API server.

• Scheduler – Tracks the status of worker nodes and determines where to run
Pods. Kube-scheduler is intended to be accessible only from within the control
plane.
• Kubernetes worker nodes are physical or virtual
machines dedicated to running containerized
applications for the cluster. In addition to running a
container engine, worker nodes host the following two
services that allow orchestration from the control plane:
• Kubelet – Runs on each worker node to orchestrate and
verify Pod execution.
• Kube-proxy – A network proxy that uses the host’s
packet filtering capability to ensure correct packet
routing in the Kubernetes cluster.
• Clusters are commonly hosted using a CSP Kubernetes
service or an on-premises Kubernetes service; CSPs
often provide additional features. They administer
most aspects of managed Kubernetes services;
however, organizations may need to handle some
Kubernetes service aspects, such as authentication
and authorization, because default CSP configurations
are typically not secure. When designing a Kubernetes
environment, organizations should understand their
responsibilities in securely maintaining the cluster.
Kubernetes Pods
• with kubernetes our ultimate aim is to deploy our
application in the form of containers on a set of
machines that are configured as worker nodes in
a cluster. However, kubernetes does not deploy
containers directly on the worker nodes. The
containers are encapsulated into a Kubernetes
object known as PODs. A POD is a single instance
of an application. A POD is the smallest object,
that you can create in kubernetes
• Here we see the simplest of simplest cases were you have a
single node kubernetes cluster with a single instance of your
application running in a single docker container encapsulated
in a POD. What if the number of users accessing your
application increase and you need to scale your application?
You need to add additional instances of your web application
to share the load. Now, were would you spin up additional
instances? Do we bring up a new container instance within
the same POD? No! We create a new POD altogether with a
new instance of the same application. As you can see we now
have two instances of our web application running on two
separate PODs on the same kubernetes system or node.
• What if the user base FURTHER increases and your current
node has no sufficient capacity? Well THEN you can always
deploy additional PODs on a new node in the cluster. You will
have a new node added to the cluster to expand the cluster’s
physical capacity. SO, what I am trying to illustrate in this slide
is that, PODs usually have a one-to-one relationship with
containers running your application. To scale UP you create
new PODs and to scale down you delete PODs. You do not
add additional containers to an existing POD to scale your
application. Also, if you are wondering how we implement all
of this and how we achieve load balancing between
containers etc, we will get into all of that in a later lecture.
 What is a Kubernetes cluster model?

• A Kubernetes cluster is a collection of linked node machines.

These are the machines on which the containers run. They are
virtual machines if the cluster is running in the cloud, though they
can be physical machines if the cluster is run on-premise.
• Kubernetes cluster includes at least one master node and, for
production, at least one worker node (but ideally a minimum of
three).
• As the primary control unit for the Kubernetes cluster, the master
node handles the Kubernetes control plane – the environment via
which the worker nodes interact with the master node. The
control plane exposes the Kubernetes API so the nodes and the
containers that host your application can be managed by
Kubernetes.
• this sparks the question - is Kubernetes a pod or
cluster? Each worker node hosts one or more
pods – a collection of containers under
Kubernetes’ control. The various workloads and
services that make up your cloud application run
in these containers. Crucially, the containers are
not tied to their node machines. Kubernetes can
move them around the cluster if necessary to
maximize stability and efficiency.
 The key components of a Kubernetes
cluster
• components of a Kubernetes cluster can be
grouped according to whether they run on the
master node or the worker nodes. The master
node is sometimes referred to simply as the
control plane. It maintains the desired state of
the cluster, covering which applications are
running and which container images their
various components are running on.
• Master node components
• Etcd Storage is a key-value data store that can be accessed by all nodes in
the cluster. It stores configuration data about the cluster’s state.
• Kube-API-Server responds to requests from the worker nodes. It receives
REST requests for modifications and also serves as a front-end to control
clusters.
• Kube-scheduler monitors resource utilization across the cluster and
schedules pods of containers accordingly. It also decides where services
will be deployed.
• Kube-controller-manager runs a number of distinct controller processes in
the background, regulating the shared state of the cluster and performing
routine tasks. When there is a change to a service, the controller
recognizes the change and initiates an update to bring the cluster up to
the desired state.
• worker node components
• The Kubelet monitors all containers in the node, continually checking they are
running and that they remain in a healthy state. Integrated into the kubelet
binary is a piece of software called cAdvisor, that auto-discovers all containers
and collects CPU, memory, file system, and network usage statistics and also
provides machine usage stats by analyzing the ‘root’ container.
• Kube Proxy acts as a network proxy and a load balancer, while also forwarding
requests to the correct pods.
• As a collection of related containers, a pod is the basic Kubernetes building
block. A pod shares network/storage between its containers and also a
specification for how to run the containers. Each pod typically has an internal
cluster IP address.
• Containers represent the smallest unit. They live inside pods and need external
IP addresses to view outside processes.
 \
WHAT is Kubernetes cluster management?

• Kubernetes cluster management is the process of managing a

Kubernetes cluster from the moment of deployment onwards.
Key to the success of Kubernetes has been its ability to
automate much of this work – and central to that ability is the
principle of a ‘desired state’.
• Kubernetes is a declarative system, which means that rather
than issue specific instructions, you provide it with
information that describes the desired state of the cluster,
usually in the form of one or more YAML files. Kubernetes will
then manage the cluster automatically. If it detects a change –
if a container fails, for example – it will perform the necessary
actions to return the cluster to that desired state.
 REFERENCE LINK
• https://www.weave.works/blog/kubernetes-cl
uster
• https://kubernetes.io/docs/concepts/cluster-a
dministration/networking/
• https://kubernetes.io/docs/reference/
kubectl/