# Cluster Architecture
Source: https://docs.karchunt.com/docs/kubernetes/introduction/cluster-architecture/cluster-architecture



## Cluster & Node Concepts

Let's understand the basic concepts of **Cluster** and **Node** in Kubernetes.

<AccordionGroup>
  <Accordion title="Cluster" icon="chart-network">
    ```mermaid theme={"theme":"github-dark-dimmed"}
    flowchart
      subgraph "Cluster"
        id["Master Node (Control Plane)"]
        id1["Node 1 (Worker Node)"]
        id2["Node 2 (Worker Node)"]
      end
    ```

    A Kubernetes **cluster** is a **set of nodes grouped together** to run containerized applications. It consists of a **control plane (master node)** and **worker nodes** which can help to **distribute workloads** across multiple machines, **providing high availability and scalability**.

    For example, the application will still be accessible even if one of the worker nodes fails, as the workload can be automatically rescheduled to another node in the cluster.
  </Accordion>

  <Accordion title="Node" icon="share-nodes">
    A node is a **worker machine**, it can be either a physical or virtual machine depending on the Kubernetes cluster.

    Each of the node is **managed by the control plane (master node)** and a node can have **multiple pods** running on it. This is also where the **containers will be launched and executed**. The node is responsible for **running the pods** and **providing the necessary resources** (CPU, memory, etc.) for the containers to run.

    For example, if you have a cluster with 3 worker nodes, and you deploy an application that requires 3 replicas, Kubernetes will automatically distribute the pods across the available nodes to ensure high availability and efficient resource utilization.
  </Accordion>
</AccordionGroup>

## Core Components

<Frame>
  <img alt="cluster-architecture" />
</Frame>

Before we dive into the architecture of a Kubernetes cluster, let's briefly review the **core components** that make up a Kubernetes cluster:

<AccordionGroup>
  <Accordion title="Control Plane Components" icon="tower-control">
    ```mermaid theme={"theme":"github-dark-dimmed"}
    flowchart
      subgraph "Master Node (Control Plane)"
        id1[Controller Manager] --> kube-apiserver
        id2[kube-scheduler] --> kube-apiserver
        kube-apiserver --> id[ETCD cluster]
      end
    ```

    The **control plane (master node)** is a node that is responsible for **managing the cluster**, **planning**, **scheduling the pods** to run on the worker nodes, and **monitoring the cluster's state** to ensure that the desired state of the cluster is maintained. Basically, it stores the information regarding the cluster such as the nodes, pods, configs, and more.

    Also, it will **transfer the workload of the failed node** to another **healthy node** to ensure the availability of the application.

    You can think of the control plane as the **brain** of the Kubernetes cluster, it makes all the decisions and manages the overall state of the cluster. These tasks are performed by the master node through a set of components known as the **control plane components**, which include:

    * **kube-apiserver** - It is the **front-end** of the Kubernetes control plane that **exposes** the Kubernetes HTTP API. It's the **entry point** for all the REST commands used to **manage (orchestrate) the cluster operations**.
    * **ETCD** - It's a **distributed key-value store** that is used to **store all the cluster data**, including the state of the cluster, configuration, date, and metadata.
    * **kube-scheduler (scheduler)** - It is responsible for **identifying and scheduling** the pods on nodes. It **only decides** which pod goes to which node, but it does not actually deploy the pod on the node, that is the responsibility of the kubelet.
    * **kube-controller-manager** - It is responsible for **managing various controllers** that are responsible for **ensuring the desired state of the cluster**. Each controller has different functions to take care of its side, such as:
      * **Node Controller** - It is responsible for **monitoring the nodes** and **taking action** when a node goes down or becomes unresponsive.
      * **Replication Controller** - It is responsible for **ensuring that the desired number of pod replicas** are running at any given time.
      * **Endpoints Controller** - It is responsible for **managing the endpoints** that are used to connect services to pods.
      * **Service Account & Token Controllers** - They are responsible for **managing service accounts and tokens** that are used for authentication and authorization in the cluster.

    <Note>
      Master node can be **hosted** in the form of **container**.
    </Note>
  </Accordion>

  <Accordion title="Worker Node Components" icon="person-carry-box">
    ```mermaid theme={"theme":"github-dark-dimmed"}
    flowchart
      subgraph "Worker Node"
        id1[kubelet]
        id2[kube-proxy]
        id3[container-runtime]
      end
    ```

    The **worker node** is a node that is responsible for **hosting application as containers** and **running the applications**. It's where the actual work happens in the Kubernetes cluster. The worker node is **managed by the control plane (master node)** and it runs the pods that are **scheduled by the kube-scheduler**.

    The worker node consists of the following components:

    * **kubelet** - It is responsible for **registering the node** with the **kube-apiserver**. It will **create the pod** on the node when it **receives the instructions** from the **kube-apiserver**, and **monitor the node** and **container/pod state** to ensure that the desired state of the cluster is maintained.
    * **kube-proxy** - It is reponsible for **creating/maintaining appropriate routing/network rules** when a new service is created to **establish communication** between containers via services within the cluster. It also **handles network traffic** and **load balancing** for the services running on the worker node.
    * **container-runtime** - It is responsible for **running the containers** on the worker node. Kubernetes supports several container runtimes, such as **Docker**, **containerd**, and **CRI-O**. The container runtime is responsible for **pulling the container images**, **starting and stopping the containers**, and **managing the container lifecycle**.

    <Note>
      Kubernetes supports other runtime engines that adhere to the OCI standards, like containerd or Rocket, so it is not necessary to install Docker before installing Kubernetes.
    </Note>
  </Accordion>
</AccordionGroup>


# Control Plane Components
Source: https://docs.karchunt.com/docs/kubernetes/introduction/cluster-architecture/control-plane-components



## kube-apiserver

<Note>
  It is designed to scale horizontally, meaning you can deploy and run multiple instances of kube-apiserver to balance the traffic between them, ensuring high availability and reliability of the Kubernetes API.
</Note>

It is the **front-end** of the Kubernetes control plane that **exposes** the Kubernetes HTTP API. It's the **entry point** for all the REST commands used to **manage (orchestrate) the cluster operations**.

Remember, **kube-apiserver** is the **only component** that **interacts** with the **etcd database**, and it serves as the **primary gateway** for all other components like (kube-scheduler, controller-manager, kubelet, kube-proxy) to **interact** with the **cluster data**.

<AccordionGroup>
  <Accordion title="Manual Installation">
    You can download the kube-apiserver binary from the [kube-apiserver releases](https://kubernetes.io/releases/download/) and **run it manually on your control-plane node**. However, this method is **not recommended for production** environments as it requires manual configuration and management of the kube-apiserver process.
  </Accordion>

  <Accordion title="kubeadm">
    If you're using **kubeadm** to setup your Kubernetes cluster, the **kube-apiserver** will be **automatically deployed as a static pod** on the control-plane node.

    You can use the `kubectl get pods -n kube-system` command to find the **kube-apiserver pod**. The kube-apiserver will be running as a static pod, which means it will be **managed by the kubelet** and will **automatically restart** if it crashes.

    ```bash icon="terminal" title="Guide to check kube-apiserver status" theme={"theme":"github-dark-dimmed"}
    # Check the kube-apiserver pod
    kubectl get pods -n kube-system

    # Check the kube-apiserver pod config options
    cat /etc/kubernetes/manifests/kube-apiserver.yaml

    # Check the kube-apiserver running process
    ps -aux | grep kube-apiserver

    # Check the kube-apiserver service
    cat /etc/systemd/system/kube-apiserver.service
    ```
  </Accordion>
</AccordionGroup>

### Process flow of getting data from the cluster

```mermaid theme={"theme":"github-dark-dimmed"}
flowchart LR
    user["User (kubectl get)"] --"HTTPS REST Request"--> api["kube-apiserver"]
    api --"Query State"--> etcd[("ETCD Cluster")]
    etcd --"Return Data"--> api
    api --"Formatted Output"--> user
```

<Note>
  You can interact with kube-apiserver by calling the Kubernetes API directly as well.
</Note>

From the above diagram, we can see that **all the requests** `kubectl` from the user will **first go to** the **kube-apiserver**.

<Expandable title="steps in detail">
  1. The user sends a request to the **kube-apiserver** using `kubectl` or any other client.
  2. The request is received by the `kube-apiserver`, which will **authenticate and validate** the request.
  3. The `kube-apiserver` will then **query** the `etcd` cluster to **retrieve the current state** of the cluster or to **update the state** based on the request.
  4. The `etcd` cluster will **return the requested data** or **acknowledge** the update to the `kube-apiserver`.
  5. Finally, the `kube-apiserver` will **format** the **response** and **send it back** to the user.
</Expandable>

### Process flow of creating a new pod

```mermaid theme={"theme":"github-dark-dimmed"}
graph TD
    1[1 User/kubectl Apply Manifest/API] --> 2(2 kube-apiserver)
    2 -->|3 Store State| 3[(3 etcd)]
    2 -->|4 Watch Event| 4(4 Scheduler)
    4 -->|5 Filter & Score Nodes| 4
    4 -->|6 Bind Pod to Node| 2
    2 -->|7 Watch Event| 5(7 Kubelet on Node)
    5 -->|8 Call| 6(8 Container Runtime)
    6 -->|9 Pull Image| 7(9 Image Registry)
    6 -->|10 Create & Start| 8(10 Container)
    5 -->|11 Update Status| 2
    2 -->|12 Update State| 3
```

<Check>
  All these steps are very similar when a change happens in the cluster. The kube-apiserver will always be the central point of communication between all the components in the cluster.
</Check>

From the above diagram, let's assume that the user wants to create a new pod using **API**.

```bash title="Create Pod via API" icon="terminal" theme={"theme":"github-dark-dimmed"}
# Reference: https://kubernetes.io/docs/reference/kubernetes-api/workload-resources/pod-v1/
curl -X POST /api/v1/namespace/default/pods
```

<Expandable title="steps in detail">
  1. The user sends a request to the **kube-apiserver** to create a new pod.
  2. The request is received by the `kube-apiserver`, which will **authenticate and validate** the request.
  3. The `kube-apiserver` wilL then **store the state** of the new pod (Create a Pod Object without the node assign) in the `etcd` cluster.
  4. The `kube-apiserver` will **watch for events** related to the new pod and **notify the scheduler**.
  5. The `scheduler` will **filter and score the nodes** to determine the best node for the new pod.
  6. The `scheduler` will **bind the pod to the selected node** and **update the state** in the `etcd` cluster.
  7. The `kubelet` on the selected node will **watch for events** related to the new pod and **call the container runtime** to create the container.
  8. The `container runtime` will **pull the necessary image** from the image registry.
  9. The `container runtime` will **create and start the container** on the node.
  10. The `kubelet` will **update the status** of the pod back to the `kube-apiserver`.
  11. The `kube-apiserver` will **update the state** of the pod in the `etcd` cluster.
</Expandable>

## etcd

<Note>
  You can refer to the [etcd documentation](https://etcd.io/) for more details about etcd, including its architecture, features, and how to use it effectively in a Kubernetes environment.
</Note>

It's a **distributed key-value store** that is used to **store all the cluster data**, including the state of the cluster, configuration, date, and metadata. The `kube-apiserver` interacts with `etcd` to **read and write data** about the **cluster's state**, making it an essential part of the Kubernetes architecture.

All information you see when you run the `kubectl get` command is from the **ETCD server**. Remember all changes made to the cluster like adding additional nodes, deploying pods, etc, will be **updated** in the **ETCD server**.

<AccordionGroup>
  <Accordion title="Manual Installation">
    You can refer to the [etcd releases](https://github.com/etcd-io/etcd/releases) to download the etcd binary and follow the [etcd installation instructions](https://etcd.io/docs/) to set up an etcd server on your control-plane node. However, this method is suitable for learning and testing purposes but is **not recommended for production environments** due to the complexity of managing and maintaining the `etcd` cluster manually.

    There is one important configuration option to note when setting up `etcd` manually: `--advertise-client-urls 'http://{IPADDRESS}:2379'`. This option specifies the address that `etcd` listens on for client requests. The default port for `etcd` is `2379`. When configuring the `kube-apiserver`, you need to ensure that it is set to connect to this URL, as the `kube-apiserver` will use this URL to communicate with the `etcd` server.
  </Accordion>

  <Accordion title="kubeadm">
    If you're using **kubeadm** to set up your Kubernetes cluster, the `etcd` server will be **automatically deployed as a static pod** on the control-plane node.

    You can use the `kubectl get pods -n kube-system` command to find the `etcd` pod. The `etcd` server will be running as a static pod, which means it will be **managed by the kubelet** and will **automatically restart** if it crashes.

    ```bash icon="terminal" title="Guide to check etcd status" theme={"theme":"github-dark-dimmed"}
    # Check the etcd pod
    kubectl get pods -n kube-system

    # Check the etcd pod config options
    cat /etc/kubernetes/manifests/etcd.yaml

    # Check the etcd running process
    ps -aux | grep etcd

    # Check the etcd service
    cat /etc/systemd/system/etcd.service
    ```

    You can also use the `etcdctl` command-line tool to interact with the `etcd` server directly. For example, you can run the following command to get all keys stored by Kubernetes in `etcd`:

    ```bash icon="terminal" title="Get all keys from etcd" theme={"theme":"github-dark-dimmed"}
    kubectl exec etcd-controlplane -n kube-system -- etcdctl get / --prefix --keys-only
    ```

    You will notice that the root directory is the **registry**, and below that are various Kubernetes objects like nodes, pods, deployments, etc, as it stores data in a specific directory structure.
  </Accordion>
</AccordionGroup>

## kube-controller manager

<Note>
  Ideally, each controller should run in its own process, but to reduce complexity, they're all compiled into a single binary and run in a single process. This design choice simplifies the deployment and management of the controllers while still allowing for scalability and reliability.
</Note>

It is responsible for **managing various controllers** that are responsible for **ensuring the desired state of the cluster**. Each controller has different functions to take care of its side, such as:

* **Node Controller** - It is responsible for **monitoring the nodes** and **taking action** when a node goes down or becomes unresponsive.
* **Replication Controller** - It is responsible for **ensuring that the desired number of pod replicas** are running at any given time.
* **Endpoints Controller** - It is responsible for **managing the endpoints** that are used to connect services to pods.
* **Service Account & Token Controllers** - They are responsible for **managing service accounts and tokens** that are used for authentication and authorization in the cluster.

```mermaid theme={"theme":"github-dark-dimmed"}
graph TD
  subgraph A[kube-controller manager]
    B[Node controller]
    C[Replication controller]
    D[Endpoints controller]
    E[More controllers...]
  end
```

The controller is a **process** that is responsible for **monitoring the state** of the various components and **resolving situations** when the **actual state does not match the desired state**.

<AccordionGroup>
  <Accordion title="Manual Installation">
    You can download the kube-controller-manager binary from the [kube-controller-manager releases](https://kubernetes.io/releases/download/) and **run it manually on your control-plane node**. However, this method is **not recommended for production** environments as it requires manual configuration and management of the kube-controller-manager process.
  </Accordion>

  <Accordion title="kubeadm">
    If you're using **kubeadm** to setup your Kubernetes cluster, the **kube-controller-manager** will be **automatically deployed as a static pod** on the control-plane node.

    You can use the `kubectl get pods -n kube-system` command to find the **kube-controller-manager pod**. The kube-controller-manager will be running as a static pod, which means it will be **managed by the kubelet** and will **automatically restart** if it crashes.

    ```bash icon="terminal" title="Guide to check kube-controller-manager status" theme={"theme":"github-dark-dimmed"}
    # Check the kube-controller-manager pod
    kubectl get pods -n kube-system

    # Check the kube-controller-manager pod config options
    cat /etc/kubernetes/manifests/kube-controller-manager.yaml

    # Check the kube-controller-manager running process
    ps -aux | grep kube-controller-manager

    # Check the kube-controller-manager service
    cat /etc/systemd/system/kube-controller-manager.service
    ```
  </Accordion>
</AccordionGroup>

### Node Controller

```mermaid theme={"theme":"github-dark-dimmed"}
flowchart RL
  subgraph "Master Node (Control Plane)"
    node-controller --> controller-manager
    controller-manager --> kube-apiserver
  end
  node1[Worker Node 1] --> kube-apiserver
  node2[Worker Node 2] --> kube-apiserver
  node3[Worker Node 3] --> kube-apiserver
```

The **node controller** is responsible for **monitoring the nodes** in the cluster and **taking action** when a node goes down or becomes unresponsive. It does this by **watching for events** related to the nodes and **updating the status** of the nodes in the `etcd` cluster.

```bash theme={"theme":"github-dark-dimmed"}
kcserver@kcserver:~$ kubectl get nodes
NAME       STATUS   ROLES           AGE   VERSION
kcserver   Ready    control-plane   40m   v1.34.6+k3s1
```

Nodes are **tested every 5 seconds** to ensure the node is **healthy**. If a node **fails to respond (not receiving heartbeats)** within **40 seconds**, the node controller will mark the node as **"NotReady"**. The node controller gives the node **5 minutes to recover** before it is marked as **"Unreachable"**. If the node remains in the "Unreachable" state for **more than 5 minutes**, the node controller will **remove all the pods from that node** and will be **provisioned those pods** to **other healthy nodes** in the cluster as long as the pod is **part of a deployment** or a **replica set**.

### Replication Controller

```mermaid theme={"theme":"github-dark-dimmed"}
flowchart RL
  subgraph "Master Node (Control Plane)"
    replication-controller --> controller-manager
    controller-manager --> kube-apiserver
  end
  node1[Worker Node 1] --> kube-apiserver
  node2[Worker Node 2] --> kube-apiserver
  node3[Worker Node 3] --> kube-apiserver
```

The **replication controller** is responsible for **ensuring that the desired number of pod replicas** are running at any given time. It does this by **watching for events** related to the pods and **updating the status** of the pods in the `etcd` cluster. If the replication controller detects that a pod is not running or has been deleted, it will **create a new pod** to replace it, ensuring that the desired number of replicas is maintained.

## kube-scheduler

<Note>
  Remember, **kubelet** is the one who will **place and create the pod** on the **node**.
</Note>

It is responsible for **identifying and scheduling** the pods on nodes. It **only decides** which pod goes to which node, but it does not actually deploy the pod on the node, that is the responsibility of the kubelet. There are some factors that it will take into account when making scheduling decisions, such as:

* **Resource Requirements** - CPU and memory requirements of the pod
* **Constraints** - Hardware, software, and policy constraints
* **Affinity and Anti-affinity** - Rules about which pods should be co-located or separated based on node or other pod labels
* **Data Locality** - Scheduling pods close to the data they need to access
* **Inter-workload Interference** - Avoiding scheduling pods that may interfere with each other on the same node
* **Deadlines** - Scheduling pods based on their deadlines and priorities

<Tip>
  The reason why we need a scheduler is because there could be multiple nodes in the cluster, and we need a way to determine which node is the best fit based on the pod requirements. For example, if a pod requires a certain amount of CPU and memory, the scheduler will need to analyze the available resources on each node to determine which node can accommodate the pod.
</Tip>

<AccordionGroup>
  <Accordion title="Manual Installation">
    You can download the kube-scheduler binary from the [kube-scheduler releases](https://kubernetes.io/releases/download/) and **run it manually on your control-plane node**. However, this method is **not recommended for production** environments as it requires manual configuration and management of the kube-scheduler process.
  </Accordion>

  <Accordion title="kubeadm">
    If you're using **kubeadm** to setup your Kubernetes cluster, the **kube-scheduler** will be **automatically deployed as a static pod** on the control-plane node.

    You can use the `kubectl get pods -n kube-system` command to find the **kube-scheduler pod**. The kube-scheduler will be running as a static pod, which means it will be **managed by the kubelet** and will **automatically restart** if it crashes.

    ```bash icon="terminal" title="Guide to check kube-scheduler status" theme={"theme":"github-dark-dimmed"}
    # Check the kube-scheduler pod
    kubectl get pods -n kube-system

    # Check the kube-scheduler pod config options
    cat /etc/kubernetes/manifests/kube-scheduler.yaml

    # Check the kube-scheduler running process
    ps -aux | grep kube-scheduler

    # Check the kube-scheduler service
    cat /etc/systemd/system/kube-scheduler.service
    ```
  </Accordion>
</AccordionGroup>

### Nodes Ranking

```mermaid theme={"theme":"github-dark-dimmed"}
---
title: kube-scheduler ranking 
---
flowchart LR
  pod["Pod (CPU: 8)"]
  subgraph "A List of nodes"
    node1["Node 1 (CPU: 4)"]
    node2["Node 2 (CPU: 10)"]
    node3["Node 3 (CPU: 20)"]
  end
  pod ---> node3
```

To determine which node is the best fit for a pod, it will rank the nodes. Here is an example, currently we have one pod with **CPU requirements of 10**. The kube scheduler will be going through **2 phases** to identify and schedule the pod on the **best node**.

1. The kube scheduler will **filter out** those **nodes** that **do not fit the requirements**. So in this case, node 1 will be filtered out as node 1 only has 4 CPUs.
2. (**Rank nodes**) By using a **priority function** or class, the kube scheduler **assigns a score** and **calculates** how much **free space** is available on the nodes after the pod is placed. The **highest score** after calculation will place the pod on that node.
   * Assuming the priority score is **5**
     * Score on node 2 = `10 - 5 = 5`
     * Score on node 3 = `20 - 5 = 15` (Win)


# Worker Node Componentes
Source: https://docs.karchunt.com/docs/kubernetes/introduction/cluster-architecture/worker-node-components



## kubelet

<Warning>
  It does not manage containers that were not created by Kubernetes.
</Warning>

It is an **agent** that runs on each node in the cluster. It is responsible for **registering the node** with the **kube-apiserver**. It will **create the pod** on the node when it **receives the instructions** from the **kube-apiserver**, and **monitor the node** and **container/pod state** to ensure that the desired state of the cluster is maintained.

<Expandable title="steps in detail">
  1. The kubelet **receives a PodSpec** from the kube-apiserver, which describes the **desired state of a pod**.
  2. The kubelet then **interacts with the container runtime** (like Docker, containerd, or CRI-O) to **create (pull the images)** and **manage the containers** that make up the pod.
  3. The kubelet **continuously monitors the state** of the node and the pods running on it, **reporting back to the kube-apiserver** to ensure that the **desired state is maintained**.
</Expandable>

By default, **kubelet is not automatically deployed on worker nodes**, as **deploy kubelet as a pod** is **not recommended**. Instead, kubelet is typically **installed** and **managed as a system service** on each worker node. This will ensure that the kubelet can **always manage the lifecycle of the pods** and **containers** on the node **without any dependencies** on the **Kubernetes control plane components**.

<Note>
  For kubelet installation, do refer [kubelet installation](https://kubernetes.io/docs/setup/production-environment/tools/kubeadm/install-kubeadm/#installing-kubeadm-kubelet-and-kubectl)

  Also, if you want to see the kubelet running process, you can use the following command:

  ```bash title="View kubelet process" icon="terminal" theme={"theme":"github-dark-dimmed"}
  # Check the kubelet process running on the node
  ps -aux | grep kubelet

  # Check the kubelet config options
  cat /var/lib/kubelet/config.yaml

  # This file contains the kubelet's configuration, 
  # - connection details to the kube-apiserver
  # - authentication credentials
  # - other settings that govern how the kubelet operates on the node
  cat /etc/kubernetes/kubelet.conf

  # Check the kubelet service
  systemctl status kubelet
  ```
</Note>

## kube-proxy

It is a **network proxy** that runs on each node in the cluster. It is reponsible for **creating/maintaining appropriate routing/network rules on nodes** when a new service is created to **establish communication** between containers via services within the cluster. It also **handles network traffic** and **load balancing** for the services running on the worker node.

```mermaid theme={"theme":"github-dark-dimmed"}
flowchart LR
  external

  subgraph Cluster
    subgraph node1
      kube-proxy1[kube-proxy]
    end

    subgraph node2
      kube-proxy2[kube-proxy]
    end

    subgraph node3
      kube-proxy3[kube-proxy]
    end

    kube-proxy1 --- kube-proxy2
    kube-proxy2 --- kube-proxy3
  end

  external --- kube-proxy1
  external --- kube-proxy2
  external --- kube-proxy3
```

Basically, these network rules allow the **pods to communicate with each other** and with **services** in the cluster, regardless of where they are running. The kube-proxy can operate in different modes, such as **iptables** or **IPVS**, to manage the network traffic and ensure that it is properly routed to the correct pods.

### How does kube-proxy work with services?

```mermaid theme={"theme":"github-dark-dimmed"}
flowchart
  pod-network(POD network) --- pod1
  pod-network(POD network) --- pod2

  subgraph "Node 2"
    pod1["Pod 2 DB (10.106.0.2)"]
  end
  subgraph "Node 1"
    pod2["Pod 1 API (10.106.0.1)"]
  end
```

Every pod can **reach other pods** within a Kubernetes cluster by **deploying a pod networking solution**. A pod network is an **internal virtual network** connecting all nodes in a cluster so that the pods can **communicate with each other**. In this example, assuming Pod 1 is an API application and Pod 2 is the database. Pod 1 can access Pod 2 using the Pod 2 IP address, but the Pod 2 IP will **not be guaranteed** the same as always.

```mermaid theme={"theme":"github-dark-dimmed"}
flowchart
  pod-network(POD network) --- pod1
  pod-network(POD network) --- pod2

  subgraph "Node 2"
    pod2["Pod 2 DB (10.106.0.2)"]
  end
  subgraph "Node 1"
    pod1["Pod 1 API (10.106.0.1)"]
  end

  service["service.db (10.106.0.3)"]

  pod2 --- service
  pod1 --- service
```

Therefore, we have to create a Kubernetes **service** object that **exposes** the database across the cluster, which means Pod 1 (API application) can access Pod 2 (database) by using the **service name** and the **service** will also **assign an IP address**.

<AccordionGroup>
  <Accordion title="But how does the service get its IP address?">
    The service gets its IP address from the **cluster IP range** that is defined in the Kubernetes cluster configuration. When a new service is created, Kubernetes will **automatically assign** it an IP address from this range.
  </Accordion>

  <Accordion title="Does the service join the same pod network as well?">
    No, the service does not join the same pod network. The service is a **virtual component** that only exists in memory and does not have a physical presence in the cluster. It is not a real object with interfaces or active listening processes.
  </Accordion>

  <Accordion title="How does the service able to accessible from any node in the cluster?">
    The service is accessible from any node in the cluster because of the **kube-proxy**. Each node in the Kubernetes cluster **runs kube-proxy**, which **looks for new services** and **creates appropriate routing rules** on the worker nodes to **forward traffic** to the **new services to pods** whenever a new service is created. It will ensure that the containers can **talk to each other via services** within the cluster.

    ```mermaid theme={"theme":"github-dark-dimmed"}
    flowchart
      pod-network(POD network) --- pod1
      pod-network(POD network) --- pod2

      subgraph "Node 2"
        direction TB
        pod2["Pod 2 DB (10.106.0.2)"]
        kube-proxy2[kube-proxy]
        pod2 --- kube-proxy2
        table2[IPTable: 10.106.0.3 --> 10.106.0.2]
      end
      subgraph "Node 1"
        direction TB
        pod1["Pod 1 API (10.106.0.1)"]
        kube-proxy1[kube-proxy]
        pod1 --- kube-proxy1
        table1[IPTable: 10.106.0.3 --> 10.106.0.2]
      end

      service["service.db (10.106.0.3)"]

      service --- kube-proxy2
      service --- kube-proxy1
    ```

    This can be done through **IPTables rules**. It will **create an IPTable rules** on each node in the cluster to know that the Database service is actually **point** to Pod 2 (database), **10.106.0.3 ---> 10.106.0.2**. This is how kube-proxy configures a new service.
  </Accordion>
</AccordionGroup>

<Note>
  For kube-proxy installation, do refer [kube-proxy installation](https://kubernetes.io/docs/reference/setup-tools/kubeadm/generated/kubeadm_init/kubeadm_init_phase_addon_kube-proxy/)

  Do take note that, kube-proxy is actually **deployed as a DaemonSet** in Kubernetes, which means that there will be **one kube-proxy pod running on each node** in the cluster. This is because kube-proxy needs to **manage the network rules** on each node to ensure that the services are properly routed to the correct pods. Also, if you want to see the kube-proxy running process, you can use the following command:

  ```bash title="View kube-proxy process" icon="terminal" theme={"theme":"github-dark-dimmed"}
  # Check the kube-proxy pod
  kubectl get pods -n kube-system
  kubectl get daemonset -n kube-system

  # Check the kube-proxy config options
  cat /var/lib/kube-proxy/config.conf
  cat /etc/kubernetes/kube-proxy.conf

  # Check the kube-proxy process running on the node
  ps -aux | grep kube-proxy
  ```
</Note>

## Container Runtime

<Note>
  What is Container Runtime Interface (CRI)?

  The Container Runtime Interface (CRI) is a **plugin interface** that allows Kubernetes to **interact with different container runtimes**. It provides a **standardized API** for Kubernetes to manage the lifecycle of containers, regardless of the underlying container runtime being used. This means that Kubernetes can work with any container runtime that implements the CRI, such as Docker, containerd, CRI-O, etc.
</Note>

It is responsible for **running and managing the lifecycle of containers** on the worker node. Kubernetes supports several container runtimes, such as **Docker**, **containerd**, and **CRI-O**. The container runtime is responsible for **pulling the container images**, **starting and stopping the containers**, and **managing the container lifecycle**.

<Note>
  Kubernetes supports other runtime engines that adhere to the OCI standards, like containerd or Rocket, so it is not necessary to install Docker before installing Kubernetes.
</Note>

<Accordion title="Why Kubernetes no need to install Docker?">
  ```mermaid theme={"theme":"github-dark-dimmed"}
  flowchart LR
    cri["Container Runtime Interface (CRI)"] ---> Kubernetes

    subgraph vendor[Container Runtime]
      rkt
      containerd
      docker[Docker Engine]
      crio[CRI-O]
    end

    vendor ---> cri
  ```

  Kubernetes only needs the **Container Runtime Interface (CRI)** to work as a **container runtime** to **perform the container operations** as long as they **adhere to the OCI standards**. Therefore, Kubernetes is compatible with any runtime engines via CRI, such as Rocket, containerd, etc. So it is **not necessary to install Docker** before installing Kubernetes.
</Accordion>

| Tool    | API Used                                                            | Primary Target       | Key Use Case                                             |
| ------- | ------------------------------------------------------------------- | -------------------- | -------------------------------------------------------- |
| crictl  | CRI API (gRPC)                                                      | Kubelet / Kubernetes | Debugging Kubernetes pods and containers.                |
| nerdctl | containerd API via its socket (/var/run/containerd/containerd.sock) | containerd daemon    | Docker-compatible CLI for modern containerd management.  |
| ctr     | containerd API via its socket (/var/run/containerd/containerd.sock) | containerd daemon    | Low-level debugging of containerd internals; minimal UX. |

### containerD & ctr

<Note>
  References

  * [https://containerd.io/](https://containerd.io/)
  * [https://github.com/containerd/containerd](https://github.com/containerd/containerd)
  * [https://github.com/containerd/containerd/tree/main/cmd/ctr](https://github.com/containerd/containerd/tree/main/cmd/ctr)
  * [https://labs.iximiuz.com/courses/containerd-cli/ctr/container-management#recap-what-is-ctr](https://labs.iximiuz.com/courses/containerd-cli/ctr/container-management#recap-what-is-ctr)
</Note>

```mermaid theme={"theme":"github-dark-dimmed"}
flowchart TD
    subgraph "Clients & Orchestrators"
        Kube["Kubernetes (Kubelet)"]
        crictl["crictl (CRI Debugging)"]
        ctr["ctr (Low-level CLI)"]
        nerdctl["nerdctl (Docker-like CLI)"]
    end

    subgraph "containerd Daemon"
        CRI["CRI Plugin (gRPC)"]
        Core["containerd Core Services"]
    end

    subgraph "Execution"
        runc["OCI Runtime (runc)"]
        cont["Running Containers"]
    end

    %% Interactions
    Kube -- "gRPC (CRI API)" --> CRI
    crictl -- "gRPC (CRI API)" --> CRI
    
    ctr -- "Native API" --> Core
    nerdctl -- "Native API" --> Core
    
    CRI -- "Internal Calls" --> Core
    Core --> runc
    runc --> cont
```

**containerD** is a **container runtime** that is designed to be **lightweight**, **efficient**, and **compliant with the <Tooltip>OCI</Tooltip>  standards**. It is a popular choice for Kubernetes clusters because of its **performance** and **simplicity**. When you install containerD, it will automatically install its command-line tool called **"ctr"**. This tool is mainly used for **debugging containerD** and is **not user-friendly**, but it provides a great way to **understand how containers work under the hood**.

Here is an example of how to use the **ctr** command-line tool to pull an image and run a container:

```bash icon="terminal" title="Pulling an image with ctr" expandable lines theme={"theme":"github-dark-dimmed"}
kcserver@kcserver:~$ ctr images pull docker.io/library/redis:alpine 
docker.io/library/redis:alpine                  fetching image content
docker.io/library/redis:alpine                  fetching image content
└──index (81b6f81d6a6c)                         complete        |++++++++++++++++++++++++++++++++++++++|
docker.io/library/redis:alpine                  fetching image content
└──index (81b6f81d6a6c)                         complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (c652b6ed7bee)                   complete        |++++++++++++++++++++++++++++++++++++++|
docker.io/library/redis:alpine                  fetching image content
└──index (81b6f81d6a6c)                         complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (c652b6ed7bee)                   complete        |++++++++++++++++++++++++++++++++++++++|
docker.io/library/redis:alpine                  fetching image content
└──index (81b6f81d6a6c)                         complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (c652b6ed7bee)                   complete        |++++++++++++++++++++++++++++++++++++++|
docker.io/library/redis:alpine                  fetching image content
└──index (81b6f81d6a6c)                         complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (c652b6ed7bee)                   complete        |++++++++++++++++++++++++++++++++++++++|
docker.io/library/redis:alpine                  fetching image content
└──index (81b6f81d6a6c)                         complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (c652b6ed7bee)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (d3882d80f0f6)                  waiting         |--------------------------------------|
docker.io/library/redis:alpine                  fetching image content
└──index (81b6f81d6a6c)                         complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (c652b6ed7bee)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (d3882d80f0f6)                  waiting         |--------------------------------------|
   ├──manifest (97b5fbd994ef)                   complete        |++++++++++++++++++++++++++++++++++++++|
docker.io/library/redis:alpine                  fetching image content
└──index (81b6f81d6a6c)                         complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (c652b6ed7bee)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (d3882d80f0f6)                  waiting         |--------------------------------------|
   ├──manifest (97b5fbd994ef)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (3b528d9f3868)                  waiting         |--------------------------------------|
docker.io/library/redis:alpine                  fetching image content
└──index (81b6f81d6a6c)                         complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (c652b6ed7bee)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (d3882d80f0f6)                  waiting         |--------------------------------------|
   ├──manifest (97b5fbd994ef)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (3b528d9f3868)                  waiting         |--------------------------------------|
docker.io/library/redis:alpine                  fetching image content
└──index (81b6f81d6a6c)                         complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (c652b6ed7bee)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (d3882d80f0f6)                  waiting         |--------------------------------------|
   ├──manifest (97b5fbd994ef)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (3b528d9f3868)                  waiting         |--------------------------------------|
docker.io/library/redis:alpine                  fetching image content
└──index (81b6f81d6a6c)                         complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (c652b6ed7bee)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (d3882d80f0f6)                  waiting         |--------------------------------------|
   ├──manifest (97b5fbd994ef)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (3b528d9f3868)                  waiting         |--------------------------------------|
docker.io/library/redis:alpine                  fetching image content
└──index (81b6f81d6a6c)                         complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (c652b6ed7bee)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (d3882d80f0f6)                  waiting         |--------------------------------------|
   ├──manifest (97b5fbd994ef)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (3b528d9f3868)                  waiting         |--------------------------------------|
   ├──manifest (c560572f2aa9)                   complete        |++++++++++++++++++++++++++++++++++++++|
docker.io/library/redis:alpine                  fetching image content
└──index (81b6f81d6a6c)                         complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (c652b6ed7bee)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (d3882d80f0f6)                  waiting         |--------------------------------------|
   ├──manifest (97b5fbd994ef)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (3b528d9f3868)                  waiting         |--------------------------------------|
   ├──manifest (c560572f2aa9)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (4a6c79b4cf2a)                  waiting         |--------------------------------------|
docker.io/library/redis:alpine                  fetching image content
└──index (81b6f81d6a6c)                         complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (c652b6ed7bee)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (d3882d80f0f6)                  waiting         |--------------------------------------|
   ├──manifest (97b5fbd994ef)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (3b528d9f3868)                  waiting         |--------------------------------------|
   ├──manifest (c560572f2aa9)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (4a6c79b4cf2a)                  waiting         |--------------------------------------|
   ├──manifest (883c7c980a2f)                   waiting         |--------------------------------------|
docker.io/library/redis:alpine                  fetching image content
└──index (81b6f81d6a6c)                         complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (c652b6ed7bee)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (d3882d80f0f6)                  waiting         |--------------------------------------|
   ├──manifest (97b5fbd994ef)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (3b528d9f3868)                  waiting         |--------------------------------------|
   ├──manifest (c560572f2aa9)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (4a6c79b4cf2a)                  waiting         |--------------------------------------|
   ├──manifest (883c7c980a2f)                   waiting         |--------------------------------------|
docker.io/library/redis:alpine                  fetching image content
└──index (81b6f81d6a6c)                         complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (c652b6ed7bee)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (d3882d80f0f6)                  waiting         |--------------------------------------|
   ├──manifest (97b5fbd994ef)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (3b528d9f3868)                  waiting         |--------------------------------------|
   ├──manifest (c560572f2aa9)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (4a6c79b4cf2a)                  waiting         |--------------------------------------|
   ├──manifest (883c7c980a2f)                   waiting         |--------------------------------------|
docker.io/library/redis:alpine                  fetching image content
└──index (81b6f81d6a6c)                         complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (c652b6ed7bee)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (d3882d80f0f6)                  waiting         |--------------------------------------|
   ├──manifest (97b5fbd994ef)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (3b528d9f3868)                  waiting         |--------------------------------------|
   ├──manifest (c560572f2aa9)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (4a6c79b4cf2a)                  waiting         |--------------------------------------|
   ├──manifest (883c7c980a2f)                   complete        |++++++++++++++++++++++++++++++++++++++|
docker.io/library/redis:alpine                  fetching image content
└──index (81b6f81d6a6c)                         complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (c652b6ed7bee)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (d3882d80f0f6)                  waiting         |--------------------------------------|
   ├──manifest (97b5fbd994ef)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (3b528d9f3868)                  waiting         |--------------------------------------|
   ├──manifest (c560572f2aa9)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (4a6c79b4cf2a)                  waiting         |--------------------------------------|
   ├──manifest (883c7c980a2f)                   complete        |++++++++++++++++++++++++++++++++++++++|
docker.io/library/redis:alpine                  fetching image content
└──index (81b6f81d6a6c)                         complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (c652b6ed7bee)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (d3882d80f0f6)                  waiting         |--------------------------------------|
   ├──manifest (97b5fbd994ef)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (3b528d9f3868)                  waiting         |--------------------------------------|
   ├──manifest (c560572f2aa9)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (4a6c79b4cf2a)                  waiting         |--------------------------------------|
   ├──manifest (883c7c980a2f)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (b95f59534a91)                  waiting         |--------------------------------------|
docker.io/library/redis:alpine                  fetching image content
└──index (81b6f81d6a6c)                         complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (c652b6ed7bee)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (d3882d80f0f6)                  waiting         |--------------------------------------|
   ├──manifest (97b5fbd994ef)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (3b528d9f3868)                  waiting         |--------------------------------------|
   ├──manifest (c560572f2aa9)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (4a6c79b4cf2a)                  waiting         |--------------------------------------|
   ├──manifest (883c7c980a2f)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (b95f59534a91)                  waiting         |--------------------------------------|
   ├──manifest (a99ef13a9ec0)                   waiting         |--------------------------------------|
docker.io/library/redis:alpine                  fetching image content
└──index (81b6f81d6a6c)                         complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (c652b6ed7bee)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (d3882d80f0f6)                  waiting         |--------------------------------------|
   ├──manifest (97b5fbd994ef)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (3b528d9f3868)                  waiting         |--------------------------------------|
   ├──manifest (c560572f2aa9)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (4a6c79b4cf2a)                  waiting         |--------------------------------------|
   ├──manifest (883c7c980a2f)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (b95f59534a91)                  waiting         |--------------------------------------|
   ├──manifest (a99ef13a9ec0)                   complete        |++++++++++++++++++++++++++++++++++++++|
docker.io/library/redis:alpine                  fetching image content
└──index (81b6f81d6a6c)                         complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (c652b6ed7bee)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (d3882d80f0f6)                  waiting         |--------------------------------------|
   ├──manifest (97b5fbd994ef)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (3b528d9f3868)                  waiting         |--------------------------------------|
   ├──manifest (c560572f2aa9)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (4a6c79b4cf2a)                  waiting         |--------------------------------------|
   ├──manifest (883c7c980a2f)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (b95f59534a91)                  waiting         |--------------------------------------|
   ├──manifest (a99ef13a9ec0)                   complete        |++++++++++++++++++++++++++++++++++++++|
docker.io/library/redis:alpine                  fetching image content
└──index (81b6f81d6a6c)                         complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (c652b6ed7bee)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (d3882d80f0f6)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (97b5fbd994ef)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (3b528d9f3868)                  waiting         |--------------------------------------|
   ├──manifest (c560572f2aa9)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (4a6c79b4cf2a)                  waiting         |--------------------------------------|
   ├──manifest (883c7c980a2f)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (b95f59534a91)                  waiting         |--------------------------------------|
   ├──manifest (a99ef13a9ec0)                   complete        |++++++++++++++++++++++++++++++++++++++|
docker.io/library/redis:alpine                  fetching image content
└──index (81b6f81d6a6c)                         complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (c652b6ed7bee)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (d3882d80f0f6)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (97b5fbd994ef)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (3b528d9f3868)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (c560572f2aa9)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (4a6c79b4cf2a)                  waiting         |--------------------------------------|
   ├──manifest (883c7c980a2f)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (b95f59534a91)                  waiting         |--------------------------------------|
   ├──manifest (a99ef13a9ec0)                   complete        |++++++++++++++++++++++++++++++++++++++|
docker.io/library/redis:alpine                  fetching image content
└──index (81b6f81d6a6c)                         complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (c652b6ed7bee)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (d3882d80f0f6)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (97b5fbd994ef)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (3b528d9f3868)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (c560572f2aa9)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (4a6c79b4cf2a)                  waiting         |--------------------------------------|
   ├──manifest (883c7c980a2f)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (b95f59534a91)                  waiting         |--------------------------------------|
   ├──manifest (a99ef13a9ec0)                   complete        |++++++++++++++++++++++++++++++++++++++|
docker.io/library/redis:alpine                  fetching image content
└──index (81b6f81d6a6c)                         complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (c652b6ed7bee)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (d3882d80f0f6)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (97b5fbd994ef)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (3b528d9f3868)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (c560572f2aa9)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (4a6c79b4cf2a)                  waiting         |--------------------------------------|
   ├──manifest (883c7c980a2f)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (b95f59534a91)                  waiting         |--------------------------------------|
   ├──manifest (a99ef13a9ec0)                   complete        |++++++++++++++++++++++++++++++++++++++|
docker.io/library/redis:alpine                  fetching image content
└──index (81b6f81d6a6c)                         complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (c652b6ed7bee)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (d3882d80f0f6)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (97b5fbd994ef)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (3b528d9f3868)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (c560572f2aa9)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (4a6c79b4cf2a)                  waiting         |--------------------------------------|
   ├──manifest (883c7c980a2f)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (b95f59534a91)                  waiting         |--------------------------------------|
   ├──manifest (a99ef13a9ec0)                   complete        |++++++++++++++++++++++++++++++++++++++|
docker.io/library/redis:alpine                  fetching image content
└──index (81b6f81d6a6c)                         complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (c652b6ed7bee)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (d3882d80f0f6)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (97b5fbd994ef)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (3b528d9f3868)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (c560572f2aa9)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (4a6c79b4cf2a)                  waiting         |--------------------------------------|
   ├──manifest (883c7c980a2f)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (b95f59534a91)                  waiting         |--------------------------------------|
   ├──manifest (a99ef13a9ec0)                   complete        |++++++++++++++++++++++++++++++++++++++|
docker.io/library/redis:alpine                  fetching image content
└──index (81b6f81d6a6c)                         complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (c652b6ed7bee)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (d3882d80f0f6)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (97b5fbd994ef)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (3b528d9f3868)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (c560572f2aa9)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (4a6c79b4cf2a)                  waiting         |--------------------------------------|
   ├──manifest (883c7c980a2f)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (b95f59534a91)                  waiting         |--------------------------------------|
   ├──manifest (a99ef13a9ec0)                   complete        |++++++++++++++++++++++++++++++++++++++|
docker.io/library/redis:alpine                  fetching image content
└──index (81b6f81d6a6c)                         complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (c652b6ed7bee)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (d3882d80f0f6)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (97b5fbd994ef)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (3b528d9f3868)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (c560572f2aa9)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (4a6c79b4cf2a)                  waiting         |--------------------------------------|
   ├──manifest (883c7c980a2f)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (b95f59534a91)                  waiting         |--------------------------------------|
   ├──manifest (a99ef13a9ec0)                   complete        |++++++++++++++++++++++++++++++++++++++|
docker.io/library/redis:alpine                  fetching image content
└──index (81b6f81d6a6c)                         complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (c652b6ed7bee)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (d3882d80f0f6)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (97b5fbd994ef)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (3b528d9f3868)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (c560572f2aa9)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (4a6c79b4cf2a)                  waiting         |--------------------------------------|
   ├──manifest (883c7c980a2f)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (b95f59534a91)                  waiting         |--------------------------------------|
   ├──manifest (a99ef13a9ec0)                   complete        |++++++++++++++++++++++++++++++++++++++|
docker.io/library/redis:alpine                  fetching image content
└──index (81b6f81d6a6c)                         complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (c652b6ed7bee)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (d3882d80f0f6)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (97b5fbd994ef)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (3b528d9f3868)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (c560572f2aa9)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (4a6c79b4cf2a)                  waiting         |--------------------------------------|
   ├──manifest (883c7c980a2f)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (b95f59534a91)                  waiting         |--------------------------------------|
   ├──manifest (a99ef13a9ec0)                   complete        |++++++++++++++++++++++++++++++++++++++|
docker.io/library/redis:alpine                  fetching image content
└──index (81b6f81d6a6c)                         complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (c652b6ed7bee)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (d3882d80f0f6)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (97b5fbd994ef)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (3b528d9f3868)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (c560572f2aa9)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (4a6c79b4cf2a)                  waiting         |--------------------------------------|
   ├──manifest (883c7c980a2f)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  ├──config (b95f59534a91)                  waiting         |--------------------------------------|
   │  └──layer (826f751c7f6d)                   waiting         |--------------------------------------|
   ├──manifest (a99ef13a9ec0)                   complete        |++++++++++++++++++++++++++++++++++++++|
docker.io/library/redis:alpine                  fetching image content
└──index (81b6f81d6a6c)                         complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (c652b6ed7bee)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (d3882d80f0f6)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (97b5fbd994ef)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (3b528d9f3868)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (c560572f2aa9)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (4a6c79b4cf2a)                  waiting         |--------------------------------------|
   ├──manifest (883c7c980a2f)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  ├──config (b95f59534a91)                  waiting         |--------------------------------------|
   │  ├──layer (826f751c7f6d)                   waiting         |--------------------------------------|
   │  └──layer (d3f91c0b9ad5)                   waiting         |--------------------------------------|
   ├──manifest (a99ef13a9ec0)                   complete        |++++++++++++++++++++++++++++++++++++++|
docker.io/library/redis:alpine                  fetching image content
└──index (81b6f81d6a6c)                         complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (c652b6ed7bee)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (d3882d80f0f6)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (97b5fbd994ef)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (3b528d9f3868)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (c560572f2aa9)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (4a6c79b4cf2a)                  waiting         |--------------------------------------|
   ├──manifest (883c7c980a2f)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  ├──config (b95f59534a91)                  waiting         |--------------------------------------|
   │  ├──layer (826f751c7f6d)                   waiting         |--------------------------------------|
   │  ├──layer (d3f91c0b9ad5)                   waiting         |--------------------------------------|
   │  └──layer (589002ba0eae)                   waiting         |--------------------------------------|
   ├──manifest (a99ef13a9ec0)                   complete        |++++++++++++++++++++++++++++++++++++++|
docker.io/library/redis:alpine                  fetching image content
└──index (81b6f81d6a6c)                         complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (c652b6ed7bee)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (d3882d80f0f6)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (97b5fbd994ef)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (3b528d9f3868)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (c560572f2aa9)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (4a6c79b4cf2a)                  waiting         |--------------------------------------|
   ├──manifest (883c7c980a2f)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  ├──config (b95f59534a91)                  waiting         |--------------------------------------|
   │  ├──layer (826f751c7f6d)                   waiting         |--------------------------------------|
   │  ├──layer (d3f91c0b9ad5)                   waiting         |--------------------------------------|
   │  ├──layer (589002ba0eae)                   waiting         |--------------------------------------|
   │  └──layer (cd9ebb746e5b)                   waiting         |--------------------------------------|
   ├──manifest (a99ef13a9ec0)                   complete        |++++++++++++++++++++++++++++++++++++++|
docker.io/library/redis:alpine                  fetching image content
└──index (81b6f81d6a6c)                         complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (c652b6ed7bee)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (d3882d80f0f6)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (97b5fbd994ef)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (3b528d9f3868)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (c560572f2aa9)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (4a6c79b4cf2a)                  waiting         |--------------------------------------|
   ├──manifest (883c7c980a2f)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  ├──config (b95f59534a91)                  waiting         |--------------------------------------|
   │  ├──layer (826f751c7f6d)                   waiting         |--------------------------------------|
   │  ├──layer (d3f91c0b9ad5)                   waiting         |--------------------------------------|
   │  ├──layer (589002ba0eae)                   waiting         |--------------------------------------|
   │  ├──layer (cd9ebb746e5b)                   waiting         |--------------------------------------|
   │  └──layer (4f4fb700ef54)                   waiting         |--------------------------------------|
   ├──manifest (a99ef13a9ec0)                   complete        |++++++++++++++++++++++++++++++++++++++|
docker.io/library/redis:alpine                  fetching image content
└──index (81b6f81d6a6c)                         complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (c652b6ed7bee)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (d3882d80f0f6)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (97b5fbd994ef)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (3b528d9f3868)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (c560572f2aa9)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (4a6c79b4cf2a)                  waiting         |--------------------------------------|
   ├──manifest (883c7c980a2f)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  ├──config (b95f59534a91)                  waiting         |--------------------------------------|
   │  ├──layer (826f751c7f6d)                   waiting         |--------------------------------------|
   │  ├──layer (d3f91c0b9ad5)                   waiting         |--------------------------------------|
   │  ├──layer (589002ba0eae)                   waiting         |--------------------------------------|
   │  ├──layer (cd9ebb746e5b)                   waiting         |--------------------------------------|
   │  ├──layer (4f4fb700ef54)                   waiting         |--------------------------------------|
   │  └──layer (cb2f87994157)                   waiting         |--------------------------------------|
   ├──manifest (a99ef13a9ec0)                   complete        |++++++++++++++++++++++++++++++++++++++|
docker.io/library/redis:alpine                  fetching image content
└──index (81b6f81d6a6c)                         complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (c652b6ed7bee)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (d3882d80f0f6)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (97b5fbd994ef)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (3b528d9f3868)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (c560572f2aa9)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (4a6c79b4cf2a)                  waiting         |--------------------------------------|
   ├──manifest (883c7c980a2f)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  ├──config (b95f59534a91)                  waiting         |--------------------------------------|
   │  ├──layer (826f751c7f6d)                   waiting         |--------------------------------------|
   │  ├──layer (d3f91c0b9ad5)                   waiting         |--------------------------------------|
   │  ├──layer (589002ba0eae)                   waiting         |--------------------------------------|
   │  ├──layer (cd9ebb746e5b)                   waiting         |--------------------------------------|
   │  ├──layer (4f4fb700ef54)                   waiting         |--------------------------------------|
   │  ├──layer (cb2f87994157)                   waiting         |--------------------------------------|
   │  └──layer (d67eeb8f9f36)                   waiting         |--------------------------------------|
   ├──manifest (a99ef13a9ec0)                   complete        |++++++++++++++++++++++++++++++++++++++|
docker.io/library/redis:alpine                  fetching image content
└──index (81b6f81d6a6c)                         complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (c652b6ed7bee)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (d3882d80f0f6)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (97b5fbd994ef)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (3b528d9f3868)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (c560572f2aa9)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (4a6c79b4cf2a)                  waiting         |--------------------------------------|
   ├──manifest (883c7c980a2f)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  ├──config (b95f59534a91)                  complete        |++++++++++++++++++++++++++++++++++++++|
   │  ├──layer (826f751c7f6d)                   waiting         |--------------------------------------|
   │  ├──layer (d3f91c0b9ad5)                   waiting         |--------------------------------------|
   │  ├──layer (589002ba0eae)                   waiting         |--------------------------------------|
   │  ├──layer (cd9ebb746e5b)                   waiting         |--------------------------------------|
   │  ├──layer (4f4fb700ef54)                   waiting         |--------------------------------------|
   │  ├──layer (cb2f87994157)                   waiting         |--------------------------------------|
   │  └──layer (d67eeb8f9f36)                   waiting         |--------------------------------------|
   ├──manifest (a99ef13a9ec0)                   complete        |++++++++++++++++++++++++++++++++++++++|
docker.io/library/redis:alpine                  fetching image content
└──index (81b6f81d6a6c)                         complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (c652b6ed7bee)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (d3882d80f0f6)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (97b5fbd994ef)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (3b528d9f3868)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (c560572f2aa9)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (4a6c79b4cf2a)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (883c7c980a2f)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  ├──config (b95f59534a91)                  complete        |++++++++++++++++++++++++++++++++++++++|
   │  ├──layer (826f751c7f6d)                   waiting         |--------------------------------------|
   │  ├──layer (d3f91c0b9ad5)                   waiting         |--------------------------------------|
   │  ├──layer (589002ba0eae)                   waiting         |--------------------------------------|
   │  ├──layer (cd9ebb746e5b)                   waiting         |--------------------------------------|
   │  ├──layer (4f4fb700ef54)                   waiting         |--------------------------------------|
   │  ├──layer (cb2f87994157)                   waiting         |--------------------------------------|
   │  └──layer (d67eeb8f9f36)                   waiting         |--------------------------------------|
   ├──manifest (a99ef13a9ec0)                   complete        |++++++++++++++++++++++++++++++++++++++|
docker.io/library/redis:alpine                  fetching image content
└──index (81b6f81d6a6c)                         complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (c652b6ed7bee)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (d3882d80f0f6)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (97b5fbd994ef)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (3b528d9f3868)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (c560572f2aa9)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (4a6c79b4cf2a)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (883c7c980a2f)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  ├──config (b95f59534a91)                  complete        |++++++++++++++++++++++++++++++++++++++|
   │  ├──layer (826f751c7f6d)                   waiting         |--------------------------------------|
   │  ├──layer (d3f91c0b9ad5)                   waiting         |--------------------------------------|
   │  ├──layer (589002ba0eae)                   waiting         |--------------------------------------|
   │  ├──layer (cd9ebb746e5b)                   waiting         |--------------------------------------|
   │  ├──layer (4f4fb700ef54)                   waiting         |--------------------------------------|
   │  ├──layer (cb2f87994157)                   waiting         |--------------------------------------|
   │  └──layer (d67eeb8f9f36)                   waiting         |--------------------------------------|
   ├──manifest (a99ef13a9ec0)                   complete        |++++++++++++++++++++++++++++++++++++++|
docker.io/library/redis:alpine                  fetching image content
└──index (81b6f81d6a6c)                         complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (c652b6ed7bee)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (d3882d80f0f6)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (97b5fbd994ef)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (3b528d9f3868)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (c560572f2aa9)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (4a6c79b4cf2a)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (883c7c980a2f)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  ├──config (b95f59534a91)                  complete        |++++++++++++++++++++++++++++++++++++++|
   │  ├──layer (826f751c7f6d)                   waiting         |--------------------------------------|
   │  ├──layer (d3f91c0b9ad5)                   waiting         |--------------------------------------|
   │  ├──layer (589002ba0eae)                   waiting         |--------------------------------------|
   │  ├──layer (cd9ebb746e5b)                   waiting         |--------------------------------------|
   │  ├──layer (4f4fb700ef54)                   waiting         |--------------------------------------|
   │  ├──layer (cb2f87994157)                   waiting         |--------------------------------------|
   │  └──layer (d67eeb8f9f36)                   waiting         |--------------------------------------|
   ├──manifest (a99ef13a9ec0)                   complete        |++++++++++++++++++++++++++++++++++++++|
docker.io/library/redis:alpine                  fetching image content
└──index (81b6f81d6a6c)                         complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (c652b6ed7bee)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (d3882d80f0f6)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (97b5fbd994ef)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (3b528d9f3868)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (c560572f2aa9)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (4a6c79b4cf2a)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (883c7c980a2f)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  ├──config (b95f59534a91)                  complete        |++++++++++++++++++++++++++++++++++++++|
   │  ├──layer (826f751c7f6d)                   waiting         |--------------------------------------|
   │  ├──layer (d3f91c0b9ad5)                   waiting         |--------------------------------------|
   │  ├──layer (589002ba0eae)                   waiting         |--------------------------------------|
   │  ├──layer (cd9ebb746e5b)                   waiting         |--------------------------------------|
   │  ├──layer (4f4fb700ef54)                   waiting         |--------------------------------------|
   │  ├──layer (cb2f87994157)                   waiting         |--------------------------------------|
   │  └──layer (d67eeb8f9f36)                   waiting         |--------------------------------------|
   ├──manifest (a99ef13a9ec0)                   complete        |++++++++++++++++++++++++++++++++++++++|
docker.io/library/redis:alpine                  fetching image content
└──index (81b6f81d6a6c)                         complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (c652b6ed7bee)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (d3882d80f0f6)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (97b5fbd994ef)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (3b528d9f3868)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (c560572f2aa9)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (4a6c79b4cf2a)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (883c7c980a2f)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  ├──config (b95f59534a91)                  complete        |++++++++++++++++++++++++++++++++++++++|
   │  ├──layer (826f751c7f6d)                   waiting         |--------------------------------------|
   │  ├──layer (d3f91c0b9ad5)                   waiting         |--------------------------------------|
   │  ├──layer (589002ba0eae)                   waiting         |--------------------------------------|
   │  ├──layer (cd9ebb746e5b)                   waiting         |--------------------------------------|
   │  ├──layer (4f4fb700ef54)                   waiting         |--------------------------------------|
   │  ├──layer (cb2f87994157)                   waiting         |--------------------------------------|
   │  └──layer (d67eeb8f9f36)                   waiting         |--------------------------------------|
   ├──manifest (a99ef13a9ec0)                   complete        |++++++++++++++++++++++++++++++++++++++|
docker.io/library/redis:alpine                  fetching image content
└──index (81b6f81d6a6c)                         complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (c652b6ed7bee)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (d3882d80f0f6)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (97b5fbd994ef)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (3b528d9f3868)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (c560572f2aa9)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (4a6c79b4cf2a)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (883c7c980a2f)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  ├──config (b95f59534a91)                  complete        |++++++++++++++++++++++++++++++++++++++|
   │  ├──layer (826f751c7f6d)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  ├──layer (d3f91c0b9ad5)                   waiting         |--------------------------------------|
   │  ├──layer (589002ba0eae)                   waiting         |--------------------------------------|
   │  ├──layer (cd9ebb746e5b)                   waiting         |--------------------------------------|
   │  ├──layer (4f4fb700ef54)                   waiting         |--------------------------------------|
   │  ├──layer (cb2f87994157)                   waiting         |--------------------------------------|
   │  └──layer (d67eeb8f9f36)                   waiting         |--------------------------------------|
   ├──manifest (a99ef13a9ec0)                   complete        |++++++++++++++++++++++++++++++++++++++|
docker.io/library/redis:alpine                  fetching image content
└──index (81b6f81d6a6c)                         complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (c652b6ed7bee)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (d3882d80f0f6)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (97b5fbd994ef)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (3b528d9f3868)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (c560572f2aa9)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (4a6c79b4cf2a)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (883c7c980a2f)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  ├──config (b95f59534a91)                  complete        |++++++++++++++++++++++++++++++++++++++|
   │  ├──layer (826f751c7f6d)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  ├──layer (d3f91c0b9ad5)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  ├──layer (589002ba0eae)                   waiting         |--------------------------------------|
   │  ├──layer (cd9ebb746e5b)                   waiting         |--------------------------------------|
   │  ├──layer (4f4fb700ef54)                   waiting         |--------------------------------------|
   │  ├──layer (cb2f87994157)                   waiting         |--------------------------------------|
   │  └──layer (d67eeb8f9f36)                   waiting         |--------------------------------------|
   ├──manifest (a99ef13a9ec0)                   complete        |++++++++++++++++++++++++++++++++++++++|
docker.io/library/redis:alpine                  fetching image content
└──index (81b6f81d6a6c)                         complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (c652b6ed7bee)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (d3882d80f0f6)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (97b5fbd994ef)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (3b528d9f3868)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (c560572f2aa9)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (4a6c79b4cf2a)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (883c7c980a2f)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  ├──config (b95f59534a91)                  complete        |++++++++++++++++++++++++++++++++++++++|
   │  ├──layer (826f751c7f6d)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  ├──layer (d3f91c0b9ad5)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  ├──layer (589002ba0eae)                   waiting         |--------------------------------------|
   │  ├──layer (cd9ebb746e5b)                   waiting         |--------------------------------------|
   │  ├──layer (4f4fb700ef54)                   waiting         |--------------------------------------|
   │  ├──layer (cb2f87994157)                   waiting         |--------------------------------------|
   │  └──layer (d67eeb8f9f36)                   complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (a99ef13a9ec0)                   complete        |++++++++++++++++++++++++++++++++++++++|
docker.io/library/redis:alpine                  fetching image content
└──index (81b6f81d6a6c)                         complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (c652b6ed7bee)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (d3882d80f0f6)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (97b5fbd994ef)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (3b528d9f3868)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (c560572f2aa9)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (4a6c79b4cf2a)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (883c7c980a2f)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  ├──config (b95f59534a91)                  complete        |++++++++++++++++++++++++++++++++++++++|
   │  ├──layer (826f751c7f6d)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  ├──layer (d3f91c0b9ad5)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  ├──layer (589002ba0eae)                   waiting         |--------------------------------------|
   │  ├──layer (cd9ebb746e5b)                   waiting         |--------------------------------------|
   │  ├──layer (4f4fb700ef54)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  ├──layer (cb2f87994157)                   waiting         |--------------------------------------|
   │  └──layer (d67eeb8f9f36)                   complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (a99ef13a9ec0)                   complete        |++++++++++++++++++++++++++++++++++++++|
docker.io/library/redis:alpine                  fetching image content
└──index (81b6f81d6a6c)                         complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (c652b6ed7bee)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (d3882d80f0f6)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (97b5fbd994ef)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (3b528d9f3868)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (c560572f2aa9)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (4a6c79b4cf2a)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (883c7c980a2f)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  ├──config (b95f59534a91)                  complete        |++++++++++++++++++++++++++++++++++++++|
   │  ├──layer (826f751c7f6d)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  ├──layer (d3f91c0b9ad5)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  ├──layer (589002ba0eae)                   waiting         |--------------------------------------|
   │  ├──layer (cd9ebb746e5b)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  ├──layer (4f4fb700ef54)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  ├──layer (cb2f87994157)                   waiting         |--------------------------------------|
   │  └──layer (d67eeb8f9f36)                   complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (a99ef13a9ec0)                   complete        |++++++++++++++++++++++++++++++++++++++|
docker.io/library/redis:alpine                  fetching image content
└──index (81b6f81d6a6c)                         complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (c652b6ed7bee)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (d3882d80f0f6)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (97b5fbd994ef)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (3b528d9f3868)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (c560572f2aa9)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (4a6c79b4cf2a)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (883c7c980a2f)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  ├──config (b95f59534a91)                  complete        |++++++++++++++++++++++++++++++++++++++|
   │  ├──layer (826f751c7f6d)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  ├──layer (d3f91c0b9ad5)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  ├──layer (589002ba0eae)                   downloading     |++++++++++++++++++++------------------|         2.0 MiB/3.7 MiB
   │  ├──layer (cd9ebb746e5b)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  ├──layer (4f4fb700ef54)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  ├──layer (cb2f87994157)                   waiting         |--------------------------------------|
   │  └──layer (d67eeb8f9f36)                   complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (a99ef13a9ec0)                   complete        |++++++++++++++++++++++++++++++++++++++|
docker.io/library/redis:alpine                  fetching image content
└──index (81b6f81d6a6c)                         complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (c652b6ed7bee)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (d3882d80f0f6)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (97b5fbd994ef)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (3b528d9f3868)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (c560572f2aa9)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (4a6c79b4cf2a)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (883c7c980a2f)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  ├──config (b95f59534a91)                  complete        |++++++++++++++++++++++++++++++++++++++|
   │  ├──layer (826f751c7f6d)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  ├──layer (d3f91c0b9ad5)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  ├──layer (589002ba0eae)                   downloading     |++++++++++++++++++++------------------|         2.0 MiB/3.7 MiB
   │  ├──layer (cd9ebb746e5b)                   extracted       |++++++++++++++++++++++++++++++++++++++|
   │  ├──layer (4f4fb700ef54)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  ├──layer (cb2f87994157)                   waiting         |--------------------------------------|
   │  └──layer (d67eeb8f9f36)                   complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (a99ef13a9ec0)                   complete        |++++++++++++++++++++++++++++++++++++++|
docker.io/library/redis:alpine                  fetching image content
└──index (81b6f81d6a6c)                         complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (c652b6ed7bee)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (d3882d80f0f6)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (97b5fbd994ef)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (3b528d9f3868)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (c560572f2aa9)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (4a6c79b4cf2a)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (883c7c980a2f)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  ├──config (b95f59534a91)                  complete        |++++++++++++++++++++++++++++++++++++++|
   │  ├──layer (826f751c7f6d)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  ├──layer (d3f91c0b9ad5)                   extracted       |++++++++++++++++++++++++++++++++++++++|
   │  ├──layer (589002ba0eae)                   downloading     |++++++++++++++++++++------------------|         2.0 MiB/3.7 MiB
   │  ├──layer (cd9ebb746e5b)                   extracted       |++++++++++++++++++++++++++++++++++++++|
   │  ├──layer (4f4fb700ef54)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  ├──layer (cb2f87994157)                   waiting         |--------------------------------------|
   │  └──layer (d67eeb8f9f36)                   complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (a99ef13a9ec0)                   complete        |++++++++++++++++++++++++++++++++++++++|
docker.io/library/redis:alpine                  fetching image content
└──index (81b6f81d6a6c)                         complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (c652b6ed7bee)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (d3882d80f0f6)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (97b5fbd994ef)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (3b528d9f3868)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (c560572f2aa9)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (4a6c79b4cf2a)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (883c7c980a2f)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  ├──config (b95f59534a91)                  complete        |++++++++++++++++++++++++++++++++++++++|
   │  ├──layer (826f751c7f6d)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  ├──layer (d3f91c0b9ad5)                   extracted       |++++++++++++++++++++++++++++++++++++++|
   │  ├──layer (589002ba0eae)                   extracted       |++++++++++++++++++++++++++++++++++++++|
   │  ├──layer (cd9ebb746e5b)                   extracted       |++++++++++++++++++++++++++++++++++++++|
   │  ├──layer (4f4fb700ef54)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  ├──layer (cb2f87994157)                   waiting         |--------------------------------------|
   │  └──layer (d67eeb8f9f36)                   complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (a99ef13a9ec0)                   complete        |++++++++++++++++++++++++++++++++++++++|
docker.io/library/redis:alpine                  fetching image content
└──index (81b6f81d6a6c)                         complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (c652b6ed7bee)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (d3882d80f0f6)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (97b5fbd994ef)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (3b528d9f3868)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (c560572f2aa9)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (4a6c79b4cf2a)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (883c7c980a2f)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  ├──config (b95f59534a91)                  complete        |++++++++++++++++++++++++++++++++++++++|
   │  ├──layer (826f751c7f6d)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  ├──layer (d3f91c0b9ad5)                   extracted       |++++++++++++++++++++++++++++++++++++++|
   │  ├──layer (589002ba0eae)                   extracted       |++++++++++++++++++++++++++++++++++++++|
   │  ├──layer (cd9ebb746e5b)                   extracted       |++++++++++++++++++++++++++++++++++++++|
   │  ├──layer (4f4fb700ef54)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  ├──layer (cb2f87994157)                   downloading     |+++++++++++++-------------------------|        10.0 MiB/29.0 MiB
   │  └──layer (d67eeb8f9f36)                   complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (a99ef13a9ec0)                   complete        |++++++++++++++++++++++++++++++++++++++|
docker.io/library/redis:alpine                  fetching image content
└──index (81b6f81d6a6c)                         complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (c652b6ed7bee)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (d3882d80f0f6)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (97b5fbd994ef)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (3b528d9f3868)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (c560572f2aa9)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (4a6c79b4cf2a)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (883c7c980a2f)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  ├──config (b95f59534a91)                  complete        |++++++++++++++++++++++++++++++++++++++|
   │  ├──layer (826f751c7f6d)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  ├──layer (d3f91c0b9ad5)                   extracted       |++++++++++++++++++++++++++++++++++++++|
   │  ├──layer (589002ba0eae)                   extracted       |++++++++++++++++++++++++++++++++++++++|
   │  ├──layer (cd9ebb746e5b)                   extracted       |++++++++++++++++++++++++++++++++++++++|
   │  ├──layer (4f4fb700ef54)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  ├──layer (cb2f87994157)                   downloading     |+++++++++++++++++++++++++++++++-------|        24.0 MiB/29.0 MiB
   │  └──layer (d67eeb8f9f36)                   complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (a99ef13a9ec0)                   complete        |++++++++++++++++++++++++++++++++++++++|
docker.io/library/redis:alpine                  fetching image content
└──index (81b6f81d6a6c)                         complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (c652b6ed7bee)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (d3882d80f0f6)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (97b5fbd994ef)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (3b528d9f3868)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (c560572f2aa9)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (4a6c79b4cf2a)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (883c7c980a2f)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  ├──config (b95f59534a91)                  complete        |++++++++++++++++++++++++++++++++++++++|
   │  ├──layer (826f751c7f6d)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  ├──layer (d3f91c0b9ad5)                   extracted       |++++++++++++++++++++++++++++++++++++++|
   │  ├──layer (589002ba0eae)                   extracted       |++++++++++++++++++++++++++++++++++++++|
   │  ├──layer (cd9ebb746e5b)                   extracted       |++++++++++++++++++++++++++++++++++++++|
   │  ├──layer (4f4fb700ef54)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  ├──layer (cb2f87994157)                   extracting      |++++++++++++++++++++++++++++----------|        21.9 MiB/29.0 MiB
   │  └──layer (d67eeb8f9f36)                   complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (a99ef13a9ec0)                   complete        |++++++++++++++++++++++++++++++++++++++|
docker.io/library/redis:alpine                  saved
└──index (81b6f81d6a6c)                         complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (c652b6ed7bee)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (d3882d80f0f6)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (97b5fbd994ef)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (3b528d9f3868)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (c560572f2aa9)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (4a6c79b4cf2a)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (883c7c980a2f)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  ├──config (b95f59534a91)                  complete        |++++++++++++++++++++++++++++++++++++++|
   │  ├──layer (826f751c7f6d)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  ├──layer (d3f91c0b9ad5)                   extracted       |++++++++++++++++++++++++++++++++++++++|
   │  ├──layer (589002ba0eae)                   extracted       |++++++++++++++++++++++++++++++++++++++|
   │  ├──layer (cd9ebb746e5b)                   extracted       |++++++++++++++++++++++++++++++++++++++|
   │  ├──layer (4f4fb700ef54)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  ├──layer (cb2f87994157)                   extracting      |++++++++++++++++++++++++++++----------|        21.9 MiB/29.0 MiB
   │  └──layer (d67eeb8f9f36)                   complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (a99ef13a9ec0)                   complete        |++++++++++++++++++++++++++++++++++++++|
docker.io/library/redis:alpine                  saved
└──index (81b6f81d6a6c)                         complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (c652b6ed7bee)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (d3882d80f0f6)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (97b5fbd994ef)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (3b528d9f3868)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (c560572f2aa9)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (4a6c79b4cf2a)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (883c7c980a2f)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  ├──config (b95f59534a91)                  complete        |++++++++++++++++++++++++++++++++++++++|
   │  ├──layer (826f751c7f6d)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  ├──layer (d3f91c0b9ad5)                   extracted       |++++++++++++++++++++++++++++++++++++++|
   │  ├──layer (589002ba0eae)                   extracted       |++++++++++++++++++++++++++++++++++++++|
   │  ├──layer (cd9ebb746e5b)                   extracted       |++++++++++++++++++++++++++++++++++++++|
   │  ├──layer (4f4fb700ef54)                   extracted       |++++++++++++++++++++++++++++++++++++++|
   │  ├──layer (cb2f87994157)                   extracting      |++++++++++++++++++++++++++++----------|        21.9 MiB/29.0 MiB
   │  └──layer (d67eeb8f9f36)                   complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (a99ef13a9ec0)                   complete        |++++++++++++++++++++++++++++++++++++++|
docker.io/library/redis:alpine                  saved
└──index (81b6f81d6a6c)                         complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (c652b6ed7bee)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (d3882d80f0f6)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (97b5fbd994ef)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (3b528d9f3868)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (c560572f2aa9)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (4a6c79b4cf2a)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (883c7c980a2f)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  ├──config (b95f59534a91)                  complete        |++++++++++++++++++++++++++++++++++++++|
   │  ├──layer (826f751c7f6d)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  ├──layer (d3f91c0b9ad5)                   extracted       |++++++++++++++++++++++++++++++++++++++|
   │  ├──layer (589002ba0eae)                   extracted       |++++++++++++++++++++++++++++++++++++++|
   │  ├──layer (cd9ebb746e5b)                   extracted       |++++++++++++++++++++++++++++++++++++++|
   │  ├──layer (4f4fb700ef54)                   extracted       |++++++++++++++++++++++++++++++++++++++|
   │  ├──layer (cb2f87994157)                   extracted       |++++++++++++++++++++++++++++++++++++++|
   │  └──layer (d67eeb8f9f36)                   complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (a99ef13a9ec0)                   complete        |++++++++++++++++++++++++++++++++++++++|
docker.io/library/redis:alpine                  saved
└──index (81b6f81d6a6c)                         complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (c652b6ed7bee)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (d3882d80f0f6)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (97b5fbd994ef)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (3b528d9f3868)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (c560572f2aa9)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (4a6c79b4cf2a)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (883c7c980a2f)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  ├──config (b95f59534a91)                  complete        |++++++++++++++++++++++++++++++++++++++|
   │  ├──layer (826f751c7f6d)                   extracted       |++++++++++++++++++++++++++++++++++++++|
   │  ├──layer (d3f91c0b9ad5)                   extracted       |++++++++++++++++++++++++++++++++++++++|
   │  ├──layer (589002ba0eae)                   extracted       |++++++++++++++++++++++++++++++++++++++|
   │  ├──layer (cd9ebb746e5b)                   extracted       |++++++++++++++++++++++++++++++++++++++|
   │  ├──layer (4f4fb700ef54)                   extracted       |++++++++++++++++++++++++++++++++++++++|
   │  ├──layer (cb2f87994157)                   extracted       |++++++++++++++++++++++++++++++++++++++|
   │  └──layer (d67eeb8f9f36)                   complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (a99ef13a9ec0)                   complete        |++++++++++++++++++++++++++++++++++++++|
docker.io/library/redis:alpine                  saved
└──index (81b6f81d6a6c)                         complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (c652b6ed7bee)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (d3882d80f0f6)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (97b5fbd994ef)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (3b528d9f3868)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (c560572f2aa9)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (4a6c79b4cf2a)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (883c7c980a2f)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  ├──config (b95f59534a91)                  complete        |++++++++++++++++++++++++++++++++++++++|
   │  ├──layer (826f751c7f6d)                   extracted       |++++++++++++++++++++++++++++++++++++++|
   │  ├──layer (d3f91c0b9ad5)                   extracted       |++++++++++++++++++++++++++++++++++++++|
   │  ├──layer (589002ba0eae)                   extracted       |++++++++++++++++++++++++++++++++++++++|
   │  ├──layer (cd9ebb746e5b)                   extracted       |++++++++++++++++++++++++++++++++++++++|
   │  ├──layer (4f4fb700ef54)                   extracted       |++++++++++++++++++++++++++++++++++++++|
   │  ├──layer (cb2f87994157)                   extracted       |++++++++++++++++++++++++++++++++++++++|
   │  └──layer (d67eeb8f9f36)                   extracted       |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (a99ef13a9ec0)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (0f50125eb34b)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (c99387bcf88c)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (8539da288423)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (c8f684a9cd49)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (ac288b8d59cc)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (d50525b44af1)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (4329dc457993)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (624ae8b29751)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (f88711430338)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (f819475c22ba)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (a7d72ed50c62)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (1e594fb983af)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (ddc29d61fa04)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (82cb19a2599c)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (a7a11b7d9343)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (87f9b4dcb882)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (dbd5b06d2bf1)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (b8239bafb8a3)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (7431382e3d7e)                  complete        |++++++++++++++++++++++++++++++++++++++|
   ├──manifest (23b09709a319)                   complete        |++++++++++++++++++++++++++++++++++++++|
   │  └──config (0beed484a8e4)                  complete        |++++++++++++++++++++++++++++++++++++++|
   └──manifest (49566e32eea1)                   complete        |++++++++++++++++++++++++++++++++++++++|
      └──config (fb01ef75ebf0)                  complete        |++++++++++++++++++++++++++++++++++++++|
application/vnd.oci.image.index.v1+json sha256:81b6f81d6a6c5b9019231a2e8eb10085e3a139a34f833dcc965a8a959b040b72
Completed pull from OCI Registry (docker.io/library/redis:alpine)       elapsed: 11.9s  total:  33.0 M  (2.8 MiB/s)
```

```bash icon="terminal" title="Running a container with ctr" expandable lines theme={"theme":"github-dark-dimmed"}
kcserver@kcserver:~$ ctr run --rm docker.io/library/redis:alpine redis-container
Starting Redis Server
1:C 12 Apr 2026 07:15:34.882 * oO0OoO0OoO0Oo Redis is starting oO0OoO0OoO0Oo
1:C 12 Apr 2026 07:15:34.882 * Redis version=8.6.2, bits=64, commit=00000000, modified=1, pid=1, just started
1:C 12 Apr 2026 07:15:34.882 * Configuration loaded
1:M 12 Apr 2026 07:15:34.882 # You requested maxclients of 10000 requiring at least 10032 max file descriptors.
1:M 12 Apr 2026 07:15:34.882 # Server can't set maximum open files to 10032 because of OS error: Operation not permitted.
1:M 12 Apr 2026 07:15:34.882 # Current maximum open files is 1024. maxclients has been reduced to 992 to compensate for low ulimit. If you need higher maxclients increase 'ulimit -n'.
1:M 12 Apr 2026 07:15:34.882 * monotonic clock: POSIX clock_gettime
1:M 12 Apr 2026 07:15:34.883 * Running mode=standalone, port=6379.
1:M 12 Apr 2026 07:15:34.883 * <bf> RedisBloom version 8.6.0 (Git=unknown)
1:M 12 Apr 2026 07:15:34.883 * <bf> Registering configuration options: [
1:M 12 Apr 2026 07:15:34.883 * <bf>     { bf-error-rate       :      0.01 }
1:M 12 Apr 2026 07:15:34.883 * <bf>     { bf-initial-size     :       100 }
1:M 12 Apr 2026 07:15:34.883 * <bf>     { bf-expansion-factor :         2 }
1:M 12 Apr 2026 07:15:34.883 * <bf>     { cf-bucket-size      :         2 }
1:M 12 Apr 2026 07:15:34.883 * <bf>     { cf-initial-size     :      1024 }
1:M 12 Apr 2026 07:15:34.883 * <bf>     { cf-max-iterations   :        20 }
1:M 12 Apr 2026 07:15:34.883 * <bf>     { cf-expansion-factor :         1 }
1:M 12 Apr 2026 07:15:34.883 * <bf>     { cf-max-expansions   :        32 }
1:M 12 Apr 2026 07:15:34.883 * <bf> ]
1:M 12 Apr 2026 07:15:34.883 * Module 'bf' loaded from /usr/local/lib/redis/modules//redisbloom.so
1:M 12 Apr 2026 07:15:34.885 * <search> Redis version found by RedisSearch : 8.6.2 - oss
1:M 12 Apr 2026 07:15:34.885 * <search> RediSearch version 8.6.0 (Git=7782b97)
1:M 12 Apr 2026 07:15:34.885 * <search> Low level api version 1 initialized successfully
1:M 12 Apr 2026 07:15:34.885 * <search> gc: ON, prefix min length: 2, min word length to stem: 4, prefix max expansions: 200, query timeout (ms): 500, timeout policy: return, oom policy: return, cursor read size: 1000, cursor max idle (ms): 300000, max doctable size: 1000000, max number of search results:  1000000, default scorer: BM25STD, 
1:M 12 Apr 2026 07:15:34.885 * <search> Initialized thread pools!
1:M 12 Apr 2026 07:15:34.885 * <search> Disabled workers threadpool of size 0
1:M 12 Apr 2026 07:15:34.885 * <search> Subscribe to config changes
1:M 12 Apr 2026 07:15:34.885 * <search> Subscribe to cluster slot migration events
1:M 12 Apr 2026 07:15:34.885 * <search> Enabled role change notification
1:M 12 Apr 2026 07:15:34.885 * <search> Cluster configuration: AUTO partitions, type: 0, coordinator timeout: 0ms
1:M 12 Apr 2026 07:15:34.885 * Module 'search' loaded from /usr/local/lib/redis/modules//redisearch.so
1:M 12 Apr 2026 07:15:34.886 * <timeseries> RedisTimeSeries version 80600, git_sha=05fd355db748676861dc4c17d19c8c1ca74c0154
1:M 12 Apr 2026 07:15:34.886 * <timeseries> Redis version found by RedisTimeSeries : 8.6.2 - oss
1:M 12 Apr 2026 07:15:34.886 * <timeseries> Registering configuration options: [
1:M 12 Apr 2026 07:15:34.886 * <timeseries>     { ts-compaction-policy   :              }
1:M 12 Apr 2026 07:15:34.886 * <timeseries>     { ts-num-threads         :            3 }
1:M 12 Apr 2026 07:15:34.886 * <timeseries>     { ts-retention-policy    :            0 }
1:M 12 Apr 2026 07:15:34.886 * <timeseries>     { ts-duplicate-policy    :        block }
1:M 12 Apr 2026 07:15:34.886 * <timeseries>     { ts-chunk-size-bytes    :         4096 }
1:M 12 Apr 2026 07:15:34.886 * <timeseries>     { ts-encoding            :   compressed }
1:M 12 Apr 2026 07:15:34.886 * <timeseries>     { ts-ignore-max-time-diff:            0 }
1:M 12 Apr 2026 07:15:34.886 * <timeseries>     { ts-ignore-max-val-diff :     0.000000 }
1:M 12 Apr 2026 07:15:34.886 * <timeseries> ]
1:M 12 Apr 2026 07:15:34.886 * <timeseries> Detected redis oss
1:M 12 Apr 2026 07:15:34.886 * <timeseries> Subscribe to ASM events
1:M 12 Apr 2026 07:15:34.886 * <timeseries> Enabled diskless replication
1:M 12 Apr 2026 07:15:34.886 * Module 'timeseries' loaded from /usr/local/lib/redis/modules//redistimeseries.so
1:M 12 Apr 2026 07:15:34.886 * <ReJSON> Created new data type 'ReJSON-RL'
1:M 12 Apr 2026 07:15:34.886 * <ReJSON> version: 80600 git sha: unknown branch: unknown
1:M 12 Apr 2026 07:15:34.886 * <ReJSON> Exported RedisJSON_V1 API
1:M 12 Apr 2026 07:15:34.886 * <ReJSON> Exported RedisJSON_V2 API
1:M 12 Apr 2026 07:15:34.886 * <ReJSON> Exported RedisJSON_V3 API
1:M 12 Apr 2026 07:15:34.886 * <ReJSON> Exported RedisJSON_V4 API
1:M 12 Apr 2026 07:15:34.886 * <ReJSON> Exported RedisJSON_V5 API
1:M 12 Apr 2026 07:15:34.886 * <ReJSON> Exported RedisJSON_V6 API
1:M 12 Apr 2026 07:15:34.886 * <ReJSON> Enabled diskless replication
1:M 12 Apr 2026 07:15:34.886 * <ReJSON> Initialized shared string cache, thread safe: true.
1:M 12 Apr 2026 07:15:34.886 * Module 'ReJSON' loaded from /usr/local/lib/redis/modules//rejson.so
1:M 12 Apr 2026 07:15:34.886 * <search> Acquired RedisJSON_V6 API
1:M 12 Apr 2026 07:15:34.921 * Server initialized
1:M 12 Apr 2026 07:15:34.921 * Ready to accept connections tcp
```

### nerdctl

<Note>
  Repository

  * [https://github.com/containerd/nerdctl](https://github.com/containerd/nerdctl)
</Note>

Just now, we mentioned that `ctr` is a **low-level tool** and not really meant for end-users. For a **more user-friendly experience**, we can use `nerdctl`, which provides a **Docker-compatible CLI** while still **leveraging containerd under the hood**. Here are some of the features that `nerdctl` offers:

* Supports Docker Compose
* Supports rootless mode
* Supports Lazy Pulling
* Supports encrypted images
* Supports P2P image distribution
* Supports container image signing and verification
* Apply Kubernetes namespaces for containers, etc
* Provides a more familiar command structure for those used to Docker

```bash icon="terminal" title="Sample commands of nerdctl" lines theme={"theme":"github-dark-dimmed"}
nerdctl
nerdctl run -it ubuntu
nerdctl run -p 8080:8080 -d webapplication
nerdctl compose -f ./docker-compose.yaml up
```

### crictl

<Note>
  Documentation

  * [https://github.com/kubernetes-sigs/cri-tools/blob/master/docs/crictl.md](https://github.com/kubernetes-sigs/cri-tools/blob/master/docs/crictl.md)
</Note>

**crictl** is a CLI tool for **CRI-compatible container runtimes**. It is primarily used for **debugging** and **managing containers** in **Kubernetes environments**. While `ctr` and `nerdctl` are **more general-purpose tools** for container management, `crictl` is specifically designed to **interact** with the **Container Runtime Interface (CRI)** used by Kubernetes.

<Info>
  Highly recommended to use crictl to [debug Kubernetes nodes](https://kubernetes.io/docs/tasks/debug/debug-cluster/crictl).
</Info>

This tool is very useful for Kubernetes administrators and developers as they can direct **debug the runtime without needing to install the full Kubernetes stack**. It allows you to **inspect and manage** containers, pods, and images directly on the node, which can be **crucial for troubleshooting issues** in a Kubernetes cluster. Remember, `crictl` is **not ideal for general container management** (create/delete) outside of Kubernetes contexts, and it is **not meant to replace tools** like `ctr` or `nerdctl` for everyday container operations.

<Warning>
  If you are using `crictl` to manage containers, for example, you create a container with `crictl` on the Kubernetes environment, you should be aware that container created by `crictl` will be deleted by Kubernetes after a while, because Kubernetes will detect that container is not managed by Kubernetes and will clean it up. As the `kubelet` will ensure a consistent state of the cluster by removing any containers that are not part of the desired state defined by Kubernetes.

  The reason is that `crictl` is using `k8s.io` namespace and interacts directly with the container runtime (like containerd) and does not register the containers it creates with Kubernetes. Therefore, Kubernetes will consider these containers as "orphaned" and will eventually clean them up to maintain the integrity of the cluster. While `ctr` and `nerdctl` both are the tools of containerd and bypass the CRI, the `kubelet` is "blind" to these containers, and thus they will not be automatically cleaned up by Kubernetes.
</Warning>

```bash icon="terminal" title="Sample commands of crictl" lines theme={"theme":"github-dark-dimmed"}
crictl help
crictl pull busybox
crictl images
crictl ps -a
crictl pods
```


# Deployment Era Comparison
Source: https://docs.karchunt.com/docs/kubernetes/introduction/deployment-era-comparison



<Tip>
  Before we dive into the details of Kubernetes, it's useful to understand the evolution of deployment strategies over time. This comparison will help you see how Kubernetes fits into the broader context of application deployment and why it has become such a popular choice for modern applications.
</Tip>

<Frame>
  <img alt="deployment-era-comparison" />
</Frame>

Below is a high-level comparison of the three deployment models based on key characteristics.

| Aspect                   | Traditional Deployment (Bare-Metal)                             | Virtualized Deployment (VMs)                                                                | Container Deployment                                                             |
| ------------------------ | --------------------------------------------------------------- | ------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------- |
| **Definition**           | Applications run directly on physical servers with the host OS. | Applications run inside virtual machines (VMs) on a hypervisor, each with its own guest OS. | Applications run in lightweight, isolated containers sharing the host OS kernel. |
| **Resource Utilization** | Low overhead; direct hardware access.                           | Moderate; VMs include full OS overhead.                                                     | High efficiency; minimal overhead per container.                                 |
| **Isolation**            | Limited; apps share the same OS, risking interference.          | Strong; each VM is fully isolated with its own OS.                                          | Good; containers isolate processes but share the kernel.                         |
| **Portability**          | Low; tied to specific hardware/OS.                              | Moderate; VMs can be moved but include OS baggage.                                          | High; containers are OS-agnostic and portable across environments.               |
| **Scalability**          | Manual; scaling requires new hardware.                          | Better; VMs can be cloned/spun up quickly.                                                  | Excellent; containers start/stop in seconds, ideal for microservices.            |
| **Management Overhead**  | High; manual provisioning, patching, and maintenance.           | Moderate; hypervisor management, but still OS-level tasks.                                  | Low; orchestration tools (e.g., Kubernetes) automate scaling and updates.        |
| **Startup Time**         | Slow; full OS boot required.                                    | Moderate; VM boot takes time.                                                               | Fast; containers start in milliseconds.                                          |
| **Security**             | Vulnerable to OS-level attacks; no built-in isolation.          | Improved; VM isolation prevents lateral movement.                                           | Strong; container isolation plus tools like seccomp/AppArmor.                    |
| **Cost**                 | High; dedicated hardware per app.                               | Moderate; shared hardware but VM licensing costs.                                           | Low; efficient resource use, open-source tools.                                  |
| **Use Cases**            | Legacy apps, monolithic systems.                                | Mixed workloads, development/testing environments.                                          | Cloud-native apps, microservices, CI/CD pipelines.                               |
| **Examples**             | Direct installation on servers (e.g., Apache on Linux).         | VMware, Hyper-V VMs.                                                                        | Docker, Kubernetes pods.                                                         |

<Panel>
  <Note>
    **Summary**:

    * **Traditional deployments** are simple but inflexible and resource-intensive.
    * **Virtualized deployments** add isolation and flexibility at the cost of overhead.
    * **Container deployments** offer the best balance of efficiency, portability, and scalability, making them ideal for modern, distributed applications.
  </Note>
</Panel>


# Kubernetes Installation
Source: https://docs.karchunt.com/docs/kubernetes/introduction/installation



## Installation Options

To setup a Kubernetes cluster, there are **several options** available, each with its own **advantages** and **use cases**. Below are some of the most popular methods for installing Kubernetes:

* **Minikube**: A local Kubernetes cluster that is easy to set up and ideal for development and testing purposes.
* **kubeadm**: A tool that provides a simple way to create a Kubernetes cluster on any machine
* **k3s**: A lightweight Kubernetes distribution designed for edge computing and IoT devices.
* **microk8s**: A minimal Kubernetes distribution that is easy to install and suitable for development and testing.

<Warning>
  In this guide, I will use **k3s** for the installation process. However, the steps may vary slightly depending on the method you choose. Always refer to the official documentation for the specific installation method you decide to use.
</Warning>

## k3s Installation

<Note>
  Here is the [documentation](https://docs.k3s.io/) as well as the [GitHub repository](https://github.com/k3s-io/k3s).
</Note>

**k3s** is a **lightweight** Kubernetes distribution that is designed to be **easy to install** and **operate**. It is ideal for edge computing, IoT devices, and development environments.

<Steps>
  <Step title="Install Script">
    The **easiest way** to **install k3s** is to use the **installation script** provided by the k3s project. You can run the following command in your terminal:

    ```bash theme={"theme":"github-dark-dimmed"}
    curl -sfL https://get.k3s.io | sh -
    ```

    This command will download and execute the installation script, which will set up **k3s**, its **dependencies**, and `kubectl` on your machine.

    <Note>
      Make sure you have **curl** installed on your system before running the above command.
    </Note>

    ```bash icon="terminal" title="Terminal Output" lines expandable theme={"theme":"github-dark-dimmed"}
    kcserver@kcserver:~$ curl -sfL https://get.k3s.io | sh -
    [sudo] password for kcserver: 
    [INFO]  Finding release for channel stable
    [INFO]  Using v1.34.6+k3s1 as release
    [INFO]  Downloading hash https://github.com/k3s-io/k3s/releases/download/v1.34.6%2Bk3s1/sha256sum-amd64.txt
    [INFO]  Downloading binary https://github.com/k3s-io/k3s/releases/download/v1.34.6%2Bk3s1/k3s
    [INFO]  Verifying binary download
    [INFO]  Installing k3s to /usr/local/bin/k3s
    [INFO]  Skipping installation of SELinux RPM
    [INFO]  Creating /usr/local/bin/kubectl symlink to k3s
    [INFO]  Creating /usr/local/bin/crictl symlink to k3s
    [INFO]  Skipping /usr/local/bin/ctr symlink to k3s, command exists in PATH at /usr/bin/ctr
    [INFO]  Creating killall script /usr/local/bin/k3s-killall.sh
    [INFO]  Creating uninstall script /usr/local/bin/k3s-uninstall.sh
    [INFO]  env: Creating environment file /etc/systemd/system/k3s.service.env
    [INFO]  systemd: Creating service file /etc/systemd/system/k3s.service
    [INFO]  systemd: Enabling k3s unit
    Created symlink /etc/systemd/system/multi-user.target.wants/k3s.service → /etc/systemd/system/k3s.service.
    [INFO]  systemd: Starting k3s
    ```
  </Step>

  <Step title="Verify Installation">
    After the installation is complete, you can verify that k3s is running by checking the status of the service:

    ```bash theme={"theme":"github-dark-dimmed"}
    sudo systemctl status k3s
    ```

    ```bash lines expandable title="Terminal Output" icon="terminal" highlight={3} theme={"theme":"github-dark-dimmed"}
    ● k3s.service - Lightweight Kubernetes
        Loaded: loaded (/etc/systemd/system/k3s.service; enabled; preset: enabled)
        Active: active (running) since Sun 2026-04-05 14:56:14 +08; 4min 11s ago
          Docs: https://k3s.io
        Process: 16564 ExecStartPre=/sbin/modprobe br_netfilter (code=exited, status=0/SUCCESS)
        Process: 16565 ExecStartPre=/sbin/modprobe overlay (code=exited, status=0/SUCCESS)
      Main PID: 16567 (k3s-server)
          Tasks: 131
        Memory: 1.4G (peak: 1.5G)
            CPU: 52.314s
        CGroup: /system.slice/k3s.service
                ├─16567 "/usr/local/bin/k3s server"
                ├─16604 "containerd "
                ├─17469 /var/lib/rancher/k3s/data/d76b59b2203578bb4cb3438338ccad2f0d3e194bef799a8957f21430b7d5f1e3/bin/containerd-shim-runc-v2 -namespace k8s.io -id 49fddc6859a2d2fbe7ff60f4bd4>
                ├─17483 /var/lib/rancher/k3s/data/d76b59b2203578bb4cb3438338ccad2f0d3e194bef799a8957f21430b7d5f1e3/bin/containerd-shim-runc-v2 -namespace k8s.io -id 39949c6a74f96b8adc19795a224>
                ├─17495 /var/lib/rancher/k3s/data/d76b59b2203578bb4cb3438338ccad2f0d3e194bef799a8957f21430b7d5f1e3/bin/containerd-shim-runc-v2 -namespace k8s.io -id 09dbfa4e70ab7c0baba199f2d9a>
                ├─18699 /var/lib/rancher/k3s/data/d76b59b2203578bb4cb3438338ccad2f0d3e194bef799a8957f21430b7d5f1e3/bin/containerd-shim-runc-v2 -namespace k8s.io -id 8ed894d3d30a49244d85dc18c88>
                └─18788 /var/lib/rancher/k3s/data/d76b59b2203578bb4cb3438338ccad2f0d3e194bef799a8957f21430b7d5f1e3/bin/containerd-shim-runc-v2 -namespace k8s.io -id c872773fae31e06fa777f93b171>

    Apr 05 14:57:20 kcserver k3s[16567]: I0405 14:57:20.545650   16567 resource_quota_monitor.go:228] "QuotaMonitor created object count evaluator" logger="resourcequota-controller" resource="t>
    Apr 05 14:57:20 kcserver k3s[16567]: I0405 14:57:20.545657   16567 resource_quota_monitor.go:228] "QuotaMonitor created object count evaluator" logger="resourcequota-controller" resource="s>
    Apr 05 14:57:20 kcserver k3s[16567]: I0405 14:57:20.545663   16567 resource_quota_monitor.go:228] "QuotaMonitor created object count evaluator" logger="resourcequota-controller" resource="a>
    Apr 05 14:57:20 kcserver k3s[16567]: I0405 14:57:20.545675   16567 resource_quota_monitor.go:228] "QuotaMonitor created object count evaluator" logger="resourcequota-controller" resource="t>
    Apr 05 14:57:20 kcserver k3s[16567]: I0405 14:57:20.545681   16567 resource_quota_monitor.go:228] "QuotaMonitor created object count evaluator" logger="resourcequota-controller" resource="s>
    Apr 05 14:57:20 kcserver k3s[16567]: I0405 14:57:20.545692   16567 resource_quota_monitor.go:228] "QuotaMonitor created object count evaluator" logger="resourcequota-controller" resource="i>
    Apr 05 14:57:20 kcserver k3s[16567]: I0405 14:57:20.545787   16567 shared_informer.go:349] "Waiting for caches to sync" controller="resource quota"
    Apr 05 14:57:20 kcserver k3s[16567]: I0405 14:57:20.746118   16567 shared_informer.go:356] "Caches are synced" controller="resource quota"
    Apr 05 14:57:21 kcserver k3s[16567]: I0405 14:57:21.155050   16567 shared_informer.go:349] "Waiting for caches to sync" controller="garbage collector"
    Apr 05 14:57:21 kcserver k3s[16567]: I0405 14:57:21.255550   16567 shared_informer.go:356] "Caches are synced" controller="garbage collector"
    ```

    You should see output indicating that the k3s service is active and running.

    <Note>
      You can also check the Kubernetes cluster status using `kubectl`:

      ```bash theme={"theme":"github-dark-dimmed"}
      kubectl get nodes
      ```

      This command should show your node(s) in a `Ready` state.

      <Warning>
        If you faced the kubectl permission issue, you can refer to step 3 of this guide to resolve it.
      </Warning>
    </Note>
  </Step>

  <Step title="Fix kubectl Permission Issue">
    <Info>
      You can refer this [link](https://devops.stackexchange.com/questions/16043/error-error-loading-config-file-etc-rancher-k3s-k3s-yaml-open-etc-rancher) for more details.
    </Info>

    If you encounter a permission issue when running `kubectl` commands (e.g., `kubectl get nodes`), it may be because the `k3s` installation creates a kubeconfig file that is owned by root. To fix this issue, you can change the ownership of the kubeconfig file to your user.

    ```bash title="Issue" icon="terminal" theme={"theme":"github-dark-dimmed"}
    kcserver@kcserver:~$ kubectl get nodes
    WARN[0000] Unable to read /etc/rancher/k3s/k3s.yaml, please start server with --write-kubeconfig-mode or --write-kubeconfig-group to modify kube config permissions 
    error: error loading config file "/etc/rancher/k3s/k3s.yaml": open /etc/rancher/k3s/k3s.yaml: permission denied
    ```

    To resolve this, run the following command to **change the ownership** of the kubeconfig file:

    ```bash title="Fix Permission Issue" icon="terminal" theme={"theme":"github-dark-dimmed"}
    mkdir ~/.kube 2> /dev/null
    export KUBECONFIG=~/.kube/config
    sudo k3s kubectl config view --raw > "$KUBECONFIG"
    chmod 600 "$KUBECONFIG"
    ```

    To make it persistent across reboots, you can add the above commands to your shell profile (e.g., `~/.bashrc` or `~/.profile`):

    ```bash theme={"theme":"github-dark-dimmed"}
    nano ~/.bashrc
    source ~/.bashrc
    ```

    Add the following lines to the end of the file:

    ```bash title="~/.bashrc" icon="terminal" theme={"theme":"github-dark-dimmed"}
    # Set KUBECONFIG environment variable
    export KUBECONFIG=~/.kube/config
    ```

    After making these changes, you should be able to run `kubectl` commands without encountering permission issues:

    ```bash title="Verify kubectl Access" icon="terminal" theme={"theme":"github-dark-dimmed"}
    kcserver@kcserver:~$ kubectl get nodes
    NAME       STATUS   ROLES           AGE   VERSION
    kcserver   Ready    control-plane   22m   v1.34.6+k3s1
    ```
  </Step>
</Steps>


# What is Kubernetes?
Source: https://docs.karchunt.com/docs/kubernetes/introduction/what-is-kubernetes



## Kubernetes Introduction

**Kubernetes** (also known as **k8s**) is an open-source platform for **automating** the **deployment**, **scaling**, and **management of containerized applications**.

## Why you should use Kubernetes?

<Tip>
  For more information, please refer to the official Kubernetes documentation:\
  [Why you need Kubernetes and what can it do](https://kubernetes.io/docs/concepts/overview/#why-you-need-kubernetes-and-what-can-it-do).
</Tip>

We know that **containers** are a great way to package and deploy applications, but in a real-world production scenario, you will need to **ensure** that your application is **highly available**, **scalable**, and **can recover from failures**.

This is where **Kubernetes** comes in. Here are some of the key features of using Kubernetes:

* **Automated deployment & scaling**: Easily deploy and **scale** applications based **on demand**.
* **Automated rollouts & rollbacks**: **Gradually roll out changes to your application** or its configuration, while monitoring application health to ensure it doesn't kill all your instances at the same time. If something goes wrong, Kubernetes will **rollback** the change for you.
* **Service Discovery & Load Balancing**: It exposes a container using a **DNS name** or its **own IP address** and **distributes network traffic** to ensure stability. If traffic to a container is too high, Kubernetes is able to **load balance** and **distribute the network traffic** to ensure the **deployment is stable**.
* **Storage orchestration**: It **automatically mounts a storage system** of your choice such as local storage, public cloud providers, and more.
* **Self-healing**: It **automatically restarts failed containers, replaces and reschedules** them when nodes die, and **kills containers** that don't respond to user-defined health checks.


# Network Architectures
Source: https://docs.karchunt.com/docs/networking/introduction/network-architectures



In this section, we will explore different network architectures that can be used in various applications. Each architecture has its own advantages and disadvantages, and the choice of architecture depends on the specific requirements of the application.

## Client-Server Architecture

<img alt="client-server-architecture" />

The client-server architecture is the **most common model** used in networking. In this architecture, there is a **central server** and **multiple clients**.

* **Server**: A server is a powerful, central computer that **provides/serves resources, data, or services** to multiple clients. It's always on and waiting for requests from clients. The server **processes the requests** and **sends back the appropriate responses** to the clients. Example of servers include web servers, database servers, and file servers.
* **Client**: A client is a computer or device that **requests resources or services** from the server. Clients can be anything from desktop computers, laptops, smartphones, to tablets. They **initiate communication (request)** with the server and **wait for responses**. Examples of clients include web browsers, email clients, and mobile apps.

<AccordionGroup>
  <Accordion title="Analogy" icon="brain">
    Think of the client-server architecture like a **restaurant**.

    * **Server**: The **restaurant staff (waiters, chefs)** who prepare and serve food.
    * **Client**: The **customers** who come to the restaurant and order food.

    The customers (clients) **request food** (resources/services) from the restaurant staff (server), who then **prepare and serve the food** back to the customers. The restaurant (server) can serve multiple customers (clients) at the same time, but the customers do not directly interact with each other.
  </Accordion>

  <Accordion title="Advantages & Disadvantages" icon="arrows-to-line">
    <Columns>
      <Card title="Advantages" type="check">
        * Easy to backup and maintain data since it's centralized on the server.
        * More secure as the server can implement security measures to protect data and resources.
        * Can handle multiple clients simultaneously, allowing for scalability.
      </Card>

      <Card title="Disadvantages" type="danger">
        * If the server goes down, clients cannot access resources or services, leading to downtime.
        * Can be expensive to set up and maintain a powerful server, especially for small applications.
        * Performance can be affected if too many clients request resources at the same time, leading to server overload.
      </Card>
    </Columns>
  </Accordion>
</AccordionGroup>

## Peer-to-Peer (P2P) Architecture

<img alt="peer-to-peer-architecture" />

In a peer-to-peer (P2P) architecture, there is **no central server**. Instead, **all devices (peers)** in the network are **equal** and can act as **both clients and servers**.

* **Peers**: Each peer/device can **act as both a client and a server**. They can **request resources** from other peers and **provide resources** to other peers. Examples of P2P applications include file-sharing networks like BitTorrent and decentralized communication platforms.

<AccordionGroup>
  <Accordion title="Analogy" icon="brain">
    Think of the peer-to-peer architecture like a **neighborhood**.

    * **Peers**: The **residents** of the neighborhood who can both **borrow and lend** items to each other.

    In this **neighborhood (P2P network)**, there is **no central authority (server)**. Each resident (peer) can **request items** from their neighbors and **offer items** to their neighbors. The residents can interact directly with each other without needing a central point of contact.
  </Accordion>

  <Accordion title="Advantages & Disadvantages" icon="arrows-to-line">
    <Columns>
      <Card title="Advantages" type="check">
        * More resilient to failures since there is no central point of failure (no server).
        * Can be more cost-effective as there is no need for a powerful central server.
        * Can provide better performance for certain applications, such as file sharing, since peers can share resources directly with each other.
      </Card>

      <Card title="Disadvantages" type="danger">
        * Managing and maintaining a P2P network can be more complex than a client-server network.
        * Security can be a concern, as there is no central authority to enforce security policies.
        * Resource availability can be unpredictable, as peers may go offline or have limited resources to share.
      </Card>
    </Columns>
  </Accordion>
</AccordionGroup>

## Hybrid Architecture

<img alt="hybrid-architecture" />

A hybrid architecture **combines** elements of both **client-server** and **peer-to-peer architectures**. In this model, there is a **central server** that **provides certain services**, but **peers** can also **communicate directly** with each other for other services.

* **Central Server**: The central server can **provide services** such as authentication, coordination, or resource management.
* **Peers**: Peers can **communicate directly** with each other for certain tasks, such as file sharing or real-time communication.

Examples of hybrid architectures include social media platforms, where a central server manages user accounts and content, but users can interact directly with each other through messaging or sharing content.

<AccordionGroup>
  <Accordion title="Analogy" icon="brain">
    Think of the hybrid architecture like a **community center**.

    * **Central Server**: The **community center staff** who manage the facility, provide resources, and coordinate activities.
    * **Peers**: The **community members** who can interact with each other directly for various activities.

    In this **community center (hybrid architecture)**, the staff (central server) provides certain services and resources, but the community members (peers) can also interact directly with each other for various activities without needing to go through the staff for every interaction.
  </Accordion>

  <Accordion title="Advantages & Disadvantages" icon="arrows-to-line">
    <Columns>
      <Card title="Advantages" type="check">
        * Combines the benefits of both client-server and peer-to-peer architectures.
        * Can provide better performance and scalability by allowing direct peer-to-peer communication for certain tasks.
        * Can offer more robust security by having a central server to enforce security policies while still allowing peer-to-peer interactions.
      </Card>

      <Card title="Disadvantages" type="danger">
        * Can be more complex to design and implement than either client-server or peer-to-peer architectures alone.
        * May require more resources to maintain both a central server and support peer-to-peer interactions.
        * Performance can be affected if the central server becomes a bottleneck for certain services or if too many peers are trying to communicate directly with each other.
      </Card>
    </Columns>
  </Accordion>
</AccordionGroup>


# Network Ownerships
Source: https://docs.karchunt.com/docs/networking/introduction/network-ownerships



## What is Network Ownership?

**Network ownership** refers to **who is responsible for managing** and **controlling** the **network resources** and **connections**. Networks can be categorized into different ownership types based on who has control over them.

## Types of Network Ownership

<img alt="network-ownerships" />

### Public Network

Public networks are **owned** and **operated** by **third-party service providers**. They're accessible to anyone and are often used for **general internet access**.

* Examples; Wi-Fi hotspots, public libraries, cafes, airports.

### Private Network

Private networks are **owned** and **managed** by individuals, organizations, or businesses. They are typically used for **internal communication** and **data sharing**. They require **authentication** for access and are **not accessible** to the general public.

* Examples; home Wi-Fi, corporate intranet, school networks.

### Hybrid Network

Hybrid networks **combine** elements  of both **public and private networks**. Most organizations use hybrid networks to **balance security** and **accessibility**.

* Examples of common hybrid scenarios;
  * **Private + Public**: A company maintains a private network for internal operations or sensitive data, while also providing public Wi-Fi for customers or visitors.
  * **On-Premises + Cloud**: A hospital uses an on-premises private network for patient records and a cloud-based public network for telemedicine services.
  * **The Bridge**: Typically, these networks are conected through a secure gateway or VPN, allowing for controlled access between the private and public segments.

### Community Network

Community networks are **owned** and **operated** by a group of individuals or organizations or local government within a specific community. They are often created to **provide internet access in underserved areas (Some areas no public internet access)** or to **foster local connectivity**.

* Examples; neighborhood mesh Wi-Fi, community mesh networks, local cooperative networks.

## Conclusion

Understanding network ownership is crucial for **network design**, **security**, and **management**. Here's a quick summary of the different network ownership types and their best use cases:

| Network Ownership Type | Description                                                                                             | Best Use Cases                                                                  |
| ---------------------- | ------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------- |
| Public Network         | Owned and operated by third-party service providers, accessible to anyone.                              | General internet access in public spaces.                                       |
| Private Network        | Owned and managed by individuals, organizations, or businesses, requiring authentication for access.    | Internal communication and data sharing within organizations.                   |
| Hybrid Network         | Combines elements of both public and private networks, often connected through a secure gateway or VPN. | Balancing security and accessibility in organizations.                          |
| Community Network      | Owned and operated by a group of individuals or organizations within a specific community.              | Providing internet access in underserved areas or fostering local connectivity. |


# Network Topologies
Source: https://docs.karchunt.com/docs/networking/introduction/network-topologies



## What is Network Topology?

Network topology refers to the **arrangement of devices** (nodes) and **connections** (links) in a computer network. It shows how different **devices are connected** and how **data flows between them**.

You can say that Network Topology is the **"architecture" blueprint of a network** or **layout of the network**. So, this is critical as choosing the right topology can impact the performance, scalability, and reliability of a network.

## Types of Network Topologies

<img alt="network-topologies" />

### Bus Topology

<Note>
  This topology rarely used today but it's important to understand it as it was one of the earliest network designs.
</Note>

All devices share a **single backbone/main cable** (the **"bus"**) with a **"terminator"** at each end.

* Pro: Very **cheap** and **easy** to set up for a small room.
* Con: If the **main cable breaks** anywhere, the **entire network crashes**. Plus, data collisions happen often because everyone is "talking" on the same wire.

### Star Topology

<Note>
  This is the most popular topology used in modern LANs and homes.
</Note>

All devices are connected to a **central hub** or **switch**.

* Pro: If **one cable breaks**, only that device goes offline. The **rest remain unaffected**.
* Con: If the **central hub/switch fails**, the **whole network** goes **down**.

### Ring Topology

In this topology, each device is **connected to exactly two other devices**, forming a **circular data path**. It means that **data travels in one direction** around the circle, passing through each device until it reaches its destination. Here is an example, if there are 5 devices (A, B, C, D, E) connected in a ring topology, the data will flow like this: **A → B → C → D → E → A**.

* Pro: Data flows in an **orderly loop**, so there are **no collisions**.
* Con: The concept is similar to the Bus topology, if one **workstation goes down** or a **cable is cut**, the **loop is broken** and the **whole network stops working**.

### Mesh Topology

In this topology, **every device** is **connected to every other device**. It means that there are **multiple paths for data** to travel between any two devices. For example, if there are 4 devices (A, B, C, D) in a mesh topology, A is connected to B, C, and D; B is connected to A, C, and D; C is connected to A, B, and D; and D is connected to A, B, and C.

* Pro: It's **reliable** because if one path is blocked or a wire is cut, the data just **takes a different "street"** to get there.
* Con: Very **complex** and **expensive** to set up due to the **large number of connections** required. But, the "Wireless Mesh" is common in modern home Wi-Fi systems like Eero or Google Nest, which provides the benefits of a mesh topology without the need for extensive cabling.

<Note>
  Calculation for the number of connections in a mesh topology:\
  `N * (N - 1) / 2`, where N is the number of devices. So, if there are 4 devices, the total number of connections would be `4 * (4 - 1) / 2 = 6` connections.
</Note>

### Tree Topology

<Note>
  This is the standard layout for large corporate networks or school campuses, where you have a central backbone with branches extending out to different departments or buildings.
</Note>

This topology is a **hierarchical structure** that combines characteristics of both **star** and **bus** topologies. It consists of **multiple levels** of devices, with a **root node** at the top and **branches** extending downwards. Each branch can have its own sub-branches, creating a **tree-like** structure. For example, in a tree topology, you might have a central server (root node - server/router) connected to several switches (branches), and each switch is connected to multiple workstations or devices (sub-branches).

* Pro: It allows for **scalability** and **easy management** of devices. If one branch fails, you can **easily add or remove** devices without affecting the entire network.
* Con: If the **root node fails**, the **entire network** can be affected. Also, it can be more **complex to set up** compared to simpler topologies like star or bus.

You can think of it as **"star of stars"** or **"family tree"**.

### Hybrid Topology

This topology is a **combination of two or more different topologies**. For example, a company might have several **Star topologies** for different departments, all connected together in a **Tree topology** or **Mesh topology** for backbone connectivity.

The hybrid topology allows organizations to **leverage the advantages** of different topologies while **mitigating their weaknesses**.

* Pro: It offers **flexibility** and can be **tailored to specific needs**. You can choose the best topology for each part of the network.
* Con: It can be **complex to design and manage** due to the mix of different topologies. It may require more **resources** and **expertise** to maintain.

## Conclusion

Choosing the right network topology is crucial for ensuring **efficient data flow**, **scalability**, and **reliability** of a network. Each topology has its own advantages and disadvantages, so it's important to consider the **specific needs of your network** when making a decision. Here's a quick summary of the different topologies and their best use cases:

| Topology | Best Use Case                                           | What happens if a device fails?                                    |
| -------- | ------------------------------------------------------- | ------------------------------------------------------------------ |
| Bus      | Small, temporary networks                               | The entire network crashes                                         |
| Star     | Home networks, small offices                            | Only the failed device goes offline                                |
| Tree     | Large corporate networks, school campuses               | Only the affected branch is impacted                               |
| Mesh     | High-reliability requirements (Banks, hospitals)        | Data finds an alternative path, so the network remains operational |
| Hybrid   | Complex network environments (Multi-site organizations) | Impact depends on the specific topology used                       |


# Type of Networks
Source: https://docs.karchunt.com/docs/networking/introduction/type-of-networks



Networks can be classified based on the **physical area (Geographical)** or **distance** that the network covers. The range is starting from small personal networks to large global networks.

<img alt="geographical-area" />

### PAN (Personal Area Network)

A **PAN** is a network that is used for communication between devices in **close proximity**.

* **Range**: 1 to 10 meters
* **Technologies**: Bluetooth, NFS, USB
* **Example**: Smartphone connecting to a wireless headset or a smartwatch

### LAN (Local Area Network)

A **LAN** is one of the most common types of networks, which is used to connect devices within a **limited area**.

* **Range**: A single room, a home, or a building
* **Technologies**: Ethernet, Wi-Fi
* **Example**: A home network connecting computers, smartphones, and printers

### CAN (Campus Area Network)

A **CAN** is a network that **connects multiple LANs** within a **limited/specific geographical area**. It's bigger than a LAN but smaller than a city-wide network.

* **Range**: University campus, corporate headquarters
* **Technologies**: Fiber optics, Switches
* **Example**: A university campus network connecting different departments, libraries, lecture halls, etc

### MAN (Metropolitan Area Network)

A **MAN** is a network that covers an **entire city** or a **large town/campus**. It's often used to connect mulitple LANs across a town.

* **Range**: City or large town/campus
* **Technologies**: Fiber, Microwave links
* **Example**: A city's free public Wi-Fi network or a university campus network connecting multiple buildings across the city

### WAN (Wide Area Network)

A **WAN** is a network that covers a **large geographical area**, such as multiple cities, countries, or even continents. WANs are used to connect smaller networks (like LANs and MANs) over long distances, but they do not necessarily span the entire globe.

* **Range**: Country, continent, or intercontinental
* **Technologies**: Leased lines, Satellites, Internet
* **Example**: A multinational company's private network connecting offices in different countries; the Internet as a collection of interconnected WANs

### GAN (Global Area Network)

A **GAN** is a network that covers the **entire globe**. It is essentially a network of WANs, providing worldwide connectivity. The Internet is the best-known example of a GAN, as it connects billions of devices globally using a combination of satellite, undersea cables, and other technologies.

* **Range**: Global
* **Technologies**: Satellite communication, Undersea cables
* **Example**: The Internet, which is a global network connecting billions of devices worldwide


# What is a Network?
Source: https://docs.karchunt.com/docs/networking/introduction/what-is-a-network



## Network Introduction

A network is a **collection of devices** (often called **nodes**) that are **connected together** so that they can communicate with each other to **exchange data** and **resources**. A network consists of two main components.

<Columns>
  <Card title="Nodes (The Devices)" icon="computer">
    The devices in a network can include computers, servers, printers, smartphones, routers, switches and other electronic devices. Any device **connected to a network** is considered a node.
  </Card>

  <Card title="Links (The Connections)" icon="circle-nodes">
    The connections between the devices in a network are called links. These links can be **physical** (like Ethernet cables) or **wireless** (like Wi-Fi). They allow the devices to **communicate** and **share** data with each other.
  </Card>
</Columns>

<Frame>
  <img alt="what-is-a-network" />
</Frame>

<Tip>
  You can think of a network as a transportation system for data. The devices are like cities, and the connections between them are like roads. Just as cars travel on roads to get from one city to another, data travels through the connections in a network to get from one device to another.
</Tip>

## How networks work?

<Frame>
  <img alt="how-networks-work" />
</Frame>

<Note>
  What is a Packet?

  A packet is a small unit of data that is transmitted over a network. When you send data over the internet, it is broken down into smaller pieces called packets. A packet can be broken down into three main parts:

  * Header (Label): Contains information about the packet, such as the source and destination IP addresses, packet number, protocol, and time-to-live (TTL).
  * Payload (Actual Data): The heart of the package, which contains the actual data being transmitted, such as a portion of a web page, an email message, or a file.
  * Trailer (Footer): Contains error-checking information to ensure that the packet has been transmitted correctly. It may include a checksum or cyclic redundancy check (CRC) to detect any errors that may have occurred during transmission. It uses mathematical calculation to verify whether the integrity of the packet is intact or not. If the calculated value does not match the value in the trailer, it indicates that the packet has been corrupted during transmission and may need to be retransmitted.
</Note>

1. You want to access a website on your laptop.
2. You type the website's address (URL) into your browser and hit enter.
3. Your laptop sends a request to the **router**, which is the device that connects your home network to the internet.
4. The router sends the request to the Internet. Data is **split into small packets** and **transmitted** across multiple devices and networks until it reaches the server hosting the website.
5. The destination server **receives the packets** and **reassembles** the data to process your request.
6. The server sends the response back in the form of data packets, which travel back through the network to your laptop.
7. Your laptop receives the packets, reassembles them, and displays the website in your browser.

## Why do we need networks?

Without networks, each device would be **isolated** and unable to communicate or share resources with other devices. Networks enable:

* **Resource sharing**: Instead of each user needing their own printer, they can share a single printer on the network. This is more cost-effective and efficient.
* **Instant communication and collaboration**: Networks allow users to communicate and collaborate in real-time, regardless of their physical location. This is essential for businesses, education, and social interactions. For example, tools like Email, Slack, etc.
* **Centralized data management**: Networks allow for centralized storage and management of data, making it easier to back up, secure, and access information from multiple devices.
* **Access to the internet**: Networks provide access to the internet, which is a vast resource of information, services, and communication tools. This has transformed how we work, learn, and interact with the world.