Kubernetes is also known as ‘k8s‘. This word comes from the Greek language, which means a pilot or helmsman.
Kubernetes is an extensible, portable, and open-source platform designed by Google in 2014. It’s mainly employed to automate the deployment, scaling, and operations of the container-based applications across the cluster of nodes. It’s also designed for managing the services of containerized apps using different methods which provide the scalability, predictability, and high availability.
It’s actually an enhanced version of ‘Borg’ for managing the long-running processes and batch jobs. Nowadays, many cloud services offer a Kubernetes-based infrastructure on which it can be deployed as the platform-providing service. This technique or concept works with many container tools, like docker, and follows the client-server architecture.

Key Objects of Kubernetes

Subsequent are the key objects which exist within the Kubernetes:
Pod
It’s the smallest and simplest basic unit of the Kubernetes application. This object indicates the processes which are running within the cluster.
Node
A node is nothing but a single host, which is employed to run the virtual or physical machines. A node within the Kubernetes cluster is also known as a minion.
Service
A service in a Kubernetes is a logical set of pods, which works together. With the help of services, users can easily manage load balancing configurations.
ReplicaSet
A ReplicaSet within the Kubernetes is employed to identify the particular number of pod replicas are running at a given time. It replaces the replication controller because it’s more powerful and allows a user to use the “set-based” label selector.
Namespace
Kubernetes supports various virtual clusters, which are known as namespaces. It’s a way of dividing the cluster resources between two or more users.

Features of Kubernetes

Subsequent are the essential features of Kubernetes:

1. Pod: It’s a deployment unit in Kubernetes with a single Internet protocol address.
2. Horizontal Scaling: It’s an important feature within the Kubernetes. This feature uses a HorizontalPodAutoscalar to automatically increase or decrease the number of pods in a deployment, replication controller, replica set, or stateful set on the basis of observed CPU utilization.
3. Automatic Bin Packing: Kubernetes helps the user to declare the maximum and minimum resources of computers for their containers.
4. Service Discovery and load balancing: Kubernetes assigns the IP addresses and a Name of DNS for a set of containers, and also balances the load across them.
5. Automated rollouts and rollbacks: Using the rollouts, Kubernetes distributes the changes and updates to an application or its configuration. If any problem occurs within the system, then this technique rollbacks those changes for you immediately.
6. Persistent Storage: Kubernetes provides an essential feature called ‘persistent storage’ for storing the data, which cannot be lost after the pod is killed or rescheduled. Kubernetes supports various storage systems for storing the data, such as Google Compute Engine’s Persistent Disks (GCE PD) or Amazon Elastic Block Storage (EBS). It also provides the distributed file systems: NFS or GFS.
7. Self-Healing: This feature plays an important role within the concept of Kubernetes. Those containers which are failed during the execution process, Kubernetes restarts them automatically. And, those containers which do not reply to the user-defined health check, it stops them from working automatically.

Kubernetes Architecture

The architecture of Kubernetes actually follows the client-server architecture. It consists of the subsequent two main components:
1. Master Node (Control Plane)
2. Slave/worker node
Master Node or Kubernetes Control Plane
The master node in a Kubernetes architecture is employed to manage the states of a cluster. It’s actually an entry point for all types of administrative tasks. Within the Kubernetes cluster, more than one master node is present for checking the fault tolerance.
Subsequent are the four different components which exist within the Master node or Kubernetes Control plane:
1. API Server
2. Scheduler
3. Controller Manager
4. ETCD
API Server
The Kubernetes API server receives the REST commands which are sent by the user. After receiving, it validates the REST requests, process, and then executes them. After the execution of REST commands, the resulting state of a cluster is saved in ‘etcd’ as a distributed key-value store.
Scheduler
The scheduler in a master node schedules the tasks to the worker nodes. And, for every worker node, it’s employed to store the resource usage information.
In other words, it’s a process that’sresponsible for assigning pods to the available worker nodes.
Controller Manager
The Controller manager is also known as a controller. It’s a daemon that executes within the non-terminating control loops. The controllers in a master node perform a task and manage the state of the cluster. Within the Kubernetes, the controller manager executes the various types of controllers for handling the nodes, endpoints, etc.
ETCD
It’s an open-source, simple, distributed key-value storage which is employed to store the cluster data. It’s a part of a master node which is written in a GO programming language.
Now, we have learned about the functioning and components of a master node; let’s see what is the function of a slave/worker node and what are its components.
Worker/Slave node
The Worker node in a Kubernetes is also known as minions. A worker node is a physical machine that executes the applications using pods. It contains all the essential services which allow a user to assign the resources to the scheduled containers.
Subsequent are the different components which are presents within the Worker or slave node:
Kubelet
This component is an agent service that executes on each worker node in a cluster. It ensures that the pods and their containers are running smoothly. Every kubelet in each worker node communicates with the master node. It also starts, stops, and maintains the containers which are organized into pods directly by the master node.
Kube-proxy
It’s a proxy service of Kubernetes, which is executed simply on each worker node within the cluster. The main aim of this component is request forwarding. Each node interacts with the Kubernetes services through Kube-proxy.
Pods
A pod is a combination of one or more containers which logically execute together on nodes. One worker node can easily execute multiple pods.

Kubernetes – Node Components

Subsequent are the key components of Node server which are necessary to communicate with Kubernetes master.
Docker
The first requirement of each node is Docker which helps in running the encapsulated application containers in a relatively isolated but lightweight operating environment.
Kubelet Service
This is a small service in each node responsible for relaying information to and from control plane service. It interacts with etcd store to read configuration details and wright values. This communicates with the master component to receive commands and work. The kubelet process then assumes responsibility for maintaining the state of work and the node server. It manages network rules, port forwarding, etc.

Kubernetes Proxy Service

This is a proxy service which runs on each node and helps in making services available to the external host. It helps in forwarding the request to correct containers and is capable of performing primitive load balancing. It makes sure that the networking environment is predictable and accessible and at the equivalent time it’s isolated as well. It manages pods on node, volumes, secrets, creating new containers’ health checkup, etc.

Kubernetes – Master and Node Structure

The subsequent illustrations show the structure of Kubernetes Master and Node.

So, this brings us to the end of blog. This Tecklearn ‘Overview of Kubernetes and its Architecture and components’ blog helps you with commonly asked questions if you are looking out for a job in DevOps. If you wish to learn Kubernetes and build a career in DevOps domain, then check out our interactive, Continuous Orchestration using Kubernetes Training, that comes with 24*7 support to guide you throughout your learning period. Please find the link for course details:

Continuous Orchestration using Kubernetes

Continuous Orchestration using Kubernetes Training

About the Course

Tecklearn has specially designed this Continuous Orchestration using Kubernetes Training Course to advance your skills for a successful career in this domain. Kubernetes training helps you master the container orchestration tool. As part of the training, you will learn detailed Kubernetes, architecture of Kubernetes, what are Kubernetes Pods, node, how to deploy Kubernetes, creating a Kubernetes cluster, what are the various services available and how Kubernetes makes container orchestration simple. You will get an in-depth knowledge of these concepts and will be able to work on related demos. Upon completion of this online training, you will hold a solid understanding and hands-on experience with Kubernetes.

Why Should you take Continuous Orchestration using Kubernetes Training?

• The average salary for people who possess Kubernetes as a skill is $117,000. – PayScale.com
• Apple, Capital One, AT&T, Oracle, Raytheon & many other MNC’s worldwide use Kubernetes across industries.
• The Kubernetes orchestration engine powers some of the biggest and most complex deployments in the world.

What you will Learn in this Course?

Introduction to DevOps
• What is Software Development
• Software Development Life Cycle
• Why DevOps?
• What is DevOps?
• DevOps Lifecycle
• DevOps Tools
• Benefits of DevOps
• How DevOps is related to Agile Delivery
• DevOps Implementation
Continuous Orchestration using Kubernetes
• Containers and Container Orchestration
• Introduction to Kubernetes
• Docker Swarm vs Kubernetes
• Kubernetes Architecture
• Deploying Kubernetes using Kubeadms
• Alternate ways of deploying Kubernetes
• Understanding YAML
• Creating a Deployment in Kubernetes using YAML
• Creating a Service in Kubernetes
• Installing Kubernetes Dashboard
• Deploying an App using Dashboard
• Using Rolling Updates in Kubernetes

375