KUBERNETES: FROM ZERO TO HERO (PART 7) - KUBERNETES VOLUMES💥🔥
Tags: beginners, devops, kubernetes, tutorial
Published: 2022-12-27 09:50:57

In Kubernetes, a volume is a directory that is accessible to the containers in a pod. It allows you to store and share data among the containers in the pod, and it can be used to persist data beyond the lifecycle of the pod.

Imagine 😎 that you have a pod with two containers: a web server and a database. The web server needs to store its files in a directory that the database can access. You can use a volume to create a shared directory that both containers can access. This way, the web server can store its files in the shared directory, and the database can access them.

There are several types of volumes that you can use in Kubernetes, each with its own characteristics and use cases. For example, you can use an `EmptyDir` volume to store temporary data that does not need to be persisted beyond the lifecycle of the pod. Or you can use a `GCEPersistentDisk` volume to store data that needs to be persisted beyond the lifecycle of the pod 🌈.

To use a volume in a pod, you need to specify it in the pod's configuration file. This is done by adding a `volumes` field to the configuration file, and specifying the type of volume and its parameters. You also need to add a `volumeMounts` field to the container's configuration, and specify the name of the volume and the mount path. The mount path is the directory in the container where the volume will be mounted.

For example, here is a configuration file that creates a pod with an `EmptyDir` volume and a container that mounts the volume at the `/var/www/html `directory:

```yaml
apiVersion: v1
kind: Pod
metadata:
  name: my-pod
spec:
  containers:
  - name: my-container
    image: nginx
    volumeMounts:
    - name: my-volume
      mountPath: /var/www/html
  volumes:
  - name: my-volume
    emptyDir: {}

```
This configuration file creates a pod with an `EmptyDir` volume named `my-volume`, and a container named `my-container` that runs the `nginx` image. The container mounts the volume at the `/var/www/html` directory. You can use the `kubectl create` command to create the pod in the cluster.

## Types Of Volumes

There are several types of volumes that you can use in Kubernetes, each with its own characteristics and use cases. In addition to the types of volumes that I mentioned in my previous response (such as `EmptyDir`, `GCEPersistentDisk`), Kubernetes also provides the following types of volumes:

**PersistentVolume**: This type of volume represents a piece of storage in the cluster that has been provisioned by the administrator. It can be used to store data that needs to be persisted beyond the lifecycle of the pod.

**PersistentVolumeClaim**: This type of volume represents a request for storage by a user. It allows a pod to claim a specific PersistentVolume in the cluster, and to use it to store data that needs to be persisted beyond the lifecycle of the pod.

**StorageClass**: This type of resource defines the parameters for creating a PersistentVolume. It allows the administrator to specify the type and the size of the PersistentVolume, as well as other parameters such as the access mode (e.g. `read-only` or `read-write`), the provisioner (e.g. GCE, AWS, Azure), and the reclaim policy (e.g. delete or retain).

To use a `PersistentVolumeClaim` volume in a pod, you need to create a `PersistentVolume` and a `StorageClass` first, and then create the PersistentVolumeClaim. Here is an example configuration file that creates a `PersistentVolumeClaim` volume:

```yaml
apiVersion: v1
kind: PersistentVolume
metadata:
  name: my-pv
spec:
  capacity:
    storage: 1Gi
  accessModes:
    - ReadWriteOnce
  persistentVolumeReclaimPolicy: Retain
  gcePersistentDisk:
    pdName: my-disk
    fsType: ext4
---
apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: standard
provisioner: kubernetes.io/gce-pd
parameters:
  type: pd-standard
---
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: my-pvc
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 1Gi
  storageClassName: standard

```
This configuration file creates a `PersistentVolume` named `my-pv` that uses a GCE persistent disk as the backing store. It also creates a StorageClass named standard that specifies the parameters for creating the `PersistentVolume`. Finally, it creates a `PersistentVolumeClaim` named `my-pvc` that claims the `PersistentVolume` and requests a storage capacity of `1Gi`.

To create the PersistentVolume, the StorageClass, and the PersistentVolumeClaim in the cluster, you can use the `kubectl create -f` command, passing the configuration file as an argument:

```bash
kubectl create -f pvc.yaml
```
To use the PersistentVolumeClaim volume in a pod, you need to specify it in the pod's configuration file, using the persistentVolumeClaim field. Here is an example configuration file that creates a pod with a PersistentVolumeClaim volume:

```yaml
apiVersion: v1
kind: Pod
metadata:
  name: my-pod
spec:
  containers:
  - name: my-container
    image: nginx
    volumeMounts:
    - name: my-volume
      mountPath: /var/www/html
  volumes:
  - name: my-volume
    persistentVolumeClaim:
      claimName: my-pvc
```
This configuration file creates a pod with a PersistentVolumeClaim volume named `my-volume`, and a container named my-container that runs the `nginx `image. The container mounts the volume at the `/var/www/html` directory. The volume is claimed using the `my-pvc` PersistentVolumeClaim, which was created in the previous step.

To create the pod in the cluster, you can use the `kubectl create` command, passing the configuration file as an argument:

```bash
kubectl create -f pod.yaml
```
There are even more types of volumes that are being commonly used in kubernetes: 

**EmptyDir**: This type of volume is created when the pod is created, and it is deleted when the pod is deleted. It is useful for storing temporary data that does not need to be persisted beyond the lifecycle of the pod.

**HostPath**: This type of volume mounts a directory from the host's file system into the pod. It is useful for accessing data on the host from within the pod, or for debugging purposes.

**GCEPersistentDisk**: This type of volume mounts a Google Compute Engine (GCE) persistent disk into the pod. It is useful for storing data that needs to be persisted beyond the lifecycle of the pod.

**AWSElasticBlockStore**: This type of volume mounts an Amazon Web Services (AWS) Elastic Block Store (EBS) volume into the pod. It is useful for storing data that needs to be persisted beyond the lifecycle of the pod.

**AzureDisk**: This type of volume mounts an Azure Disk into the pod. It is useful for storing data that needs to be persisted beyond the lifecycle of the pod.

**NFS**: This type of volume mounts an Network File System (NFS) share into the pod. It is useful for storing data that needs to be shared among multiple pods, or that needs to be persisted beyond the lifecycle of the pod.

**ConfigMap**: This type of volume mounts a ConfigMap as a set of files into the pod. It is useful for injecting configuration data into the containers in the pod.

**Secret**: This type of volume mounts a Secret as a set of files into the pod. It is useful for injecting sensitive data into the containers in the pod. files into the pod. It is useful for injecting sensitive data into the containers in the pod.

Overall, volumes are an important part of the Kubernetes network model, and they allow you to store and share data among the containers in a pod. They provide a flexible and scalable way to persist. PersistentVolume, PersistentVolumeClaim, and StorageClass are advanced types of volumes that allow you to store and share data that needs to be persisted beyond the lifecycle of the pod. They provide a flexible and scalable way to manage the storage needs of your applications in the cluster. Although GCEPersistentDisk, AzureDisk, AWSElasticBlockStore has been deprecated, they are included here because they are worth knowing.

🌟 🔥 If you want to switch your career into tech and you are considering DevOps, you can join our online community [here](https://chat.whatsapp.com/LARpsS1xhYi75TdJYh8TMa)for live classes and FREE tutorial videos.