Kubernetes Overview
Tags: devops, kubernetes, docker
Published: 2022-06-08 21:15:00

# kubernetes
Kubernetes is a container orchestration tool, developed by Google in 2014. in simple terms, it manages containers from docker containers or from other technology.

Kubernetes basically helps you manage containerized applications made up of hundreds or maybe thousands of containers in different environments like physical, virtual, or cloud environments.

If you are not familiar with containers, check out my [another blog.](https://dev.to/shubhamyadav/docker-made-easy-1fej)


##  What features do orchestration tools provide?
- **High availability**: In simple words, high availability means that your application does not have any downtime, so it is always accessible by the users.

- **Scalability**: This means that the application has high performance, it loads fast and users have a very high rate of response rate from the application.

- **Disaster Recovery**:  it basically means that if the infrastructure has any problems like data is lost or the servers explode. the infrastructure has to have some kind of mechanism to pick up the data and restore it to the latest state.

- Some other features of Kubernetes are scheduling, scaling, load balancing, fault tolerance, deployment, automated rollouts, rollbacks, etc.



## Kubernetes Architecture

![kubernetes arch.png](https://cdn.hashnode.com/res/hashnode/image/upload/v1643648026823/XVdVXqBXV.png)

### Overview

Kubernetes architecture consists of two parts a master node and a worker node or node which is basically a simple server a physical or virtual machine, all the nodes join together to form a cluster.

## **Components of master node**

The master node is responsible for managing the cluster and it basically monitors and manages the nodes and the pods in a cluster so whenever there is a failure of a node it will move the workload to the other working node and take care of the overall cluster.

![master node.png](https://cdn.hashnode.com/res/hashnode/image/upload/v1643797917863/X-pnoMyKmn.png)

#### **API server**

It is the front-end for the Kubernetes control panel. The API server is responsible for the communications, it exposes APIs so that the users can interact with the API server.
The Users, management devices, and the command line interface all talk to the API server to interact with the Kubernetes cluster.

#### **scheduler**

it is responsible for scheduling the pods over multiple nodes, It can read the configuration from a configuration file, and accordingly, it selects the nodes where the pods can be scheduled.
It watches newly created pods that have no node assigned and selects a node for them to run on.
it obtains all this information from configuration files and indirectly from etcd datastore

#### **Control Manager**
there 4 types of controllers behind control manager:
- Node controller: it is responsible for noticing and responding when the nodes go down.
- Replication Controller: It is responsible for maintaining the correct numbers of pods for every replication controller object in the system.
- Endpoints Controller: It is responsible for all the services and communication.
- Service account and token controller: It is responsible for maintaining accounts and API access.

#### **etcd**
It is a distributed key-value store used to hold and manage the critical information that distributed systems need to keep running.


## **Components of worker node**

A worker node is a simple server physical or virtual machine where containers are deployed.

![worker node.png](https://cdn.hashnode.com/res/hashnode/image/upload/v1643648068494/Xf0JRtn4d.png)


#### **Kublet**

It is an agent running on each node, it communicates with the components from the master node.
kubelet make sure that containers are running and healthy in a pod. In case Kubelet notices any issues with the pods running on the worker nodes, it tries to restart the Pod on the same node or a different node.  
the kubelet takes a set of PodSpecs that are provided through various mechanisms and ensures that the containers described in those PodSpecs are running and healthy.

#### **Kube-Proxy**

It is a network agent which runs on each node and is responsible for maintaining network configuration and rules. It also exposes services to the outside world. Kube-Proxy is the core networking component in Kubernetes

#### **Pods**

A pod is the smallest unit of Kubernetes. So Pod is basically an abstraction over a container, it creates a running environment or a layer on top of the container, Pods is usually meant to run one application container inside of it, you can run multiple containers inside one pod but it's only the case if you have one application container and a helper container or some service that has to run inside of that pod,
We interact and manage the containers using Pods. 
Each Pod can communicate with each others.

#### **Containers**

Containers are Runtime Environments for containerized applications. We run container applications inside the containers. For more detailed information, check out my blog on [Docker](https://shubh22121.hashnode.dev/docker-made-easy)

### **Service and Ingress**

Service is a permanent IP address that can be attached to each pod.
The lifecycles of service and pods are not connected so even if the pod dies the service and its IP address will stay.

Ingress exposes HTTP and HTTPS routes from outside the cluster to services within the cluster. Traffic routing is controlled by rules defined on the Ingress resource.


![ingress.png](https://cdn.hashnode.com/res/hashnode/image/upload/v1643797331194/UQ20_NUM5.png)

## **Use/Installation**

**online Kubernetes labs**

The following are the online platforms/playgrounds in case you test something on Kubernetes: 

- Kubernetes playground - https://www.katacoda.com/courses/kubernetes/playground

- Play with K8s - https://labs.play-with-k8s.com/

- Play with Kubernetes classroom  - https://training.play-with-kubernetes.com/

**Kubernetes Installation tools**

#### - Minikube

minikube is a very quick way to install Kubernetes on your system especially if you have limited resources minikube will be very ideal to install and setup Kubernetes on the system, here we will be using a single system for master and for worker node so the same system it will have master instance and the worker instance.

#### - Kubeadm

**Cloud-based Kubernetes services** 

- GKE: Google Kubernetes Engine.
- AKS - Azure Kubernetes Service.
- Amazon EKS


## **usage**


```
$ brew install minikube
``` 

The above command also installs kubectl as its dependency.



```
minkube start
``` 

after this command, you can use the following command to see the nodes.

```
 $ kubectl get nodes
NAME       STATUS   ROLES                  AGE   VERSION
minikube   Ready    control-plane,master   64s   v1.20.7
``` 
the minikube has 'master' as its role.

***So there are 2 ways to create a pod ***

**1. directly :
**

```
apiVersion: v1
kind: Pod
metadata:
  name: nginx-pod
spec:
  containers:
  - name: nginx
    image: nginx:1.14.2
    ports:
    - containerPort: 80
``` 

- To create the Pod shown above, run the following command:

```
~ kubectl create -f nginx-pod.yaml
pod/nginx-pod created

``` 

- list all the pods

```
~ kubectl get pods 
NAME        READY   STATUS    RESTARTS   AGE
nginx-pod   1/1     Running   0          9m25s

``` 

- delete the pod

```
~ kubectl delete pod nginx-pod
pod "nginx-pod" deleted
``` 

**2. Using deployment**


The pod is the smallest unit in the Kubernetes cluster but usually, in practice, you are not creating pods or you are not working with pods directly. There is an abstraction layer over the pods that is called deployment, so this is what we create and that creates the pods underneath.


```
apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-depl
  labels:
    app: nginx
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:1.14.2
        ports:
        - containerPort: 80
``` 


usage: 
```
~ kubectl apply -f nginx-depl.yaml
deployment.apps/nginx-depl created
``` 

- List all the deployments

```
~ kubectl get deployment
NAME         READY   UP-TO-DATE   AVAILABLE   AGE
nginx-depl   1/1     1            1           77m
``` 

- List all the Pods.

```
~ kubectl get pods
NAME       READY   STATUS    RESTARTS   AGE
nginx-depl   1/1     Running   0          31m
``` 

~ Executing a Pod
```
~ kubectl exec -it nginx-depl -- /bin/sh
# ls
bin  boot  dev etc  home  lib lib64  media  mnt  opt proc  root  run  sbin  srv  sys  tmp  usr  var
# hostname
nginx-depl
# exit
```
- delete deployment

```
 kubectl delete deployment nginx-depl
``` 

### **What is the difference between Pods and Deployment?**

**Pods:**

- Runs a single set of containers
- Good for occasional dev purposes
- Rarely used directly in production

**Deployment:**

- Runs a set of identical pods
- Monitors the state of each pod, updating as necessary
- Good for dev
- Good for production