# Kubernetes Fundamentals: A Beginner's Guide

In the ever-evolving DevOps landscape, Kubernetes has emerged as the leading container orchestration tool, simplifying deployment, scaling, and management of containerized applications. This blog dives into Kubernetes fundamentals, architecture, and a hands-on setup guide to get you started.

---

## **What is Kubernetes?**

Kubernetes, often abbreviated as **K8s** (8 letters between K and S), is a **framework** initially developed by Google as **BORG**. It later became open-source and evolved into Kubernetes. It's a robust tool used to manage containerized applications in a clustered environment. Key features include:

* **Auto-scaling**
    
* **Auto-healing**
    
* **High availability**
    

### **Why Kubernetes?**

Modern applications often use the **Microservices** architecture, where individual services (e.g., login, order processing) operate independently. Kubernetes ensures smooth operation by managing containers, enabling auto-scaling, and providing fault tolerance.

---

## **Kubernetes Architecture**

A Kubernetes cluster comprises:

1. **Master Node**  
    The brain of the cluster responsible for managing worker nodes.
    
    Key components:
    
    * **API Server:** Central communication hub.
        
    * **Scheduler:** Assigns tasks to nodes.
        
    * **Controller Manager:** Manages cluster state and node health.
        
    * **etcd:** Stores cluster data as a key-value store.
        
    * **CNI (Container Network Interface):** Enables communication between master and worker nodes.
        
    * **Kube Proxy:** Manages communication between users and cluster applications.
        
2. **Worker Nodes**  
    The nodes where containerized applications run. Each worker node has:
    
    * **Kubelet:** Ensures node health and communicates with the API server.
        
    * **Pods:** Smallest deployable units in Kubernetes, running one or more containers.
        

### **Diagram**

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1732638309501/d4b66b63-01b3-4321-9a49-d9c03706189e.png align="center")

---

## **Kubernetes Installation**

### **Installation Options**

1. **Local**
    
    * **Minikube**
        
    * **Kops**
        
    * **KIND (Kubernetes in Docker):** We'll use KIND for this guide.
        
2. **Cloud**
    
    * **AWS EKS**
        
    * **Azure AKS**
        
    * **Google GKE**
        

---

## **Hands-On: Kubernetes with KIND**

### **Prerequisites**

* An EC2 instance (t2.medium recommended).
    
* Docker installed.
    

### **Steps**

#### **1\. Install Docker**

Use the command:

```bash
sudo apt install docker.io
```

#### **2\. Install KIND**

Download KIND for Linux:

```bash
[ $(uname -m) = x86_64 ] && curl -Lo ./kind https://kind.sigs.k8s.io/dl/v0.25.0/kind-linux-amd64
chmod +x ./kind
sudo mv ./kind /usr/local/bin/kind
```

#### **3\. Validate KIND Installation**

Check the setup using:

```bash
kind --version
```

#### **4\. Install kubectl**

Download kubectl for x86\_64:

```bash
curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl"
chmod +x kubectl
sudo mv kubectl /usr/local/bin/kubectl
```

#### **5\. Create Your First Cluster**

Use the following command:

```bash
kind create cluster --name=mycluster
```

#### **6\. Verify Cluster and Nodes**

* To list clusters:
    
    ```bash
    kind get clusters
    ```
    
* To view nodes:
    
    ```bash
    kubectl get nodes
    ```
    

#### **7\. Create a Custom Cluster Configuration**

Create a file named `config.yml` with the following content:

```yaml
kind: Cluster
apiVersion: kind.x-k8s.io/v1alpha4
nodes:
  - role: control-plane
    image: kindest/node:v1.31.2
  - role: worker
    image: kindest/node:v1.31.2
  - role: worker
    image: kindest/node:v1.31.2
```

Run the command to create the cluster:

```bash
kind create cluster --name=mycluster --config=config.yml
```

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1732638542187/02cc1928-48ba-4dfd-9868-ecb2797eba8d.png align="center")

#### **8\. Manage Namespaces**

* Create a namespace:
    
    ```bash
    kubectl create ns mynamespace
    ```
    
* List namespaces:
    
    ```bash
    kubectl get ns
    ```
    
* Delete a namespace:
    
    ```bash
    kubectl delete ns mynamespace
    ```
    

#### **9\. Deploy a Pod**

Run an Nginx container:

```bash
kubectl run nginx --image=nginx
```

Check the pod status:

```bash
kubectl get pods
```

Describe the pod for details:

```bash
kubectl describe pod/nginx
```

---

## **Key Takeaways**

* Kubernetes is the backbone of modern containerized applications, providing features like **scalability** and **resilience**.
    
* Tools like **KIND** simplify Kubernetes setup for local environments, making it accessible for beginners.
    
* Understanding the Kubernetes **architecture** and its components is crucial for mastering container orchestration.
    

---

For more details, explore the official Kubernetes documentation: [Kubernetes Docs](https://kubernetes.io/docs).

Start your Kubernetes journey today and leverage its power to manage containerized applications seamlessly! 🚀

Let me know your thoughts and experiences in the comments. 😊