How to Manage Kubernetes App Storage Like a Pro 📁 – ██FR█████ █INTELL███████████

This content originally appeared on DEV Community and was authored by Hamdi KHELIL

Managing storage in Kubernetes might seem a bit tricky at first, but don’t worry—we’re here to help! This guide will walk you through everything you need to know about Kubernetes volumes, how they work, and how to use them effectively, especially if you’re using Azure.

What Are Kubernetes Volumes?

Think of volumes as a way to store data in your Kubernetes pods that doesn’t disappear when the pod shuts down. This is super important for things like saving files, databases, or anything else that needs to stick around.

Different Types of Volumes

Kubernetes offers a bunch of different volume types, each with its own special use case. Here are some of the most common ones:

emptyDir: Temporary storage that exists as long as the pod is running. Great for things like cache or temporary files.
hostPath: Links to a file or directory on the node where your pod is running. Use this if you need direct access to the host system, but be careful—this ties your pod to that specific node.
nfs: Connects your pod to a Network File System (NFS) share. Perfect for sharing data between multiple pods.
configMap and secret: Inject configuration data or sensitive information into your pods. Handy for managing app settings or passwords securely.
csi: A flexible way to connect your pods to all kinds of storage providers, including cloud services like Azure.

Persistent Volumes (PVs) and Persistent Volume Claims (PVCs)

Let’s dive into the heart of Kubernetes storage: Persistent Volumes (PVs) and Persistent Volume Claims (PVCs).

Persistent Volumes (PV)

A Persistent Volume is like a piece of storage space in your cluster that you or Kubernetes have set up ahead of time. It lives outside of any particular pod, so your data is safe even if the pod restarts.

Example: Setting Up a Persistent Volume

Here’s how you might define a Persistent Volume:

apiVersion: v1
kind: PersistentVolume
metadata:
  name: my-pv
spec:
  capacity:
    storage: 10Gi
  accessModes:
    - ReadWriteOnce
  persistentVolumeReclaimPolicy: Retain
  storageClassName: manual
  hostPath:
    path: /mnt/data

Persistent Volume Claims (PVC)

A Persistent Volume Claim is basically your pod asking for storage. It says, “Hey, I need 10GB of space that I can read and write to.” Kubernetes then finds a PV that fits and connects it to your pod.

Example: Creating a Persistent Volume Claim

Here’s how you can request some storage:

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: my-pvc
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 10Gi
  storageClassName: manual

Making Life Easier with Dynamic Provisioning

Wouldn’t it be great if Kubernetes could automatically create the storage you need? That’s what StorageClasses are for. They tell Kubernetes how to provision storage on the fly, based on your needs.

Example: Setting Up a StorageClass in Azure

Here’s how you might define a StorageClass that uses Azure’s managed disks:

apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: azure-disk
provisioner: disk.csi.azure.com
parameters:
  skuName: Standard_LRS
  storageaccounttype: Standard_LRS

When you create a PVC with this StorageClass, Kubernetes will automatically create the PV for you. Easy, right?

Snapshots: The Backup Superpower

Now, let’s talk about Volume Snapshots—a super handy feature that lets you take a picture of your data at a specific moment. If something goes wrong, you can restore your data from that snapshot.

Setting Up Volume Snapshots in Azure

First, you’ll need a VolumeSnapshotClass, which tells Kubernetes how to create and manage these snapshots.

apiVersion: snapshot.storage.k8s.io/v1
kind: VolumeSnapshotClass
metadata:
  name: azure-disk-snapshot-class
spec:
  deletionPolicy: Delete
  driver: disk.csi.azure.com

Taking a Snapshot

Here’s how to create a snapshot of your PVC:

apiVersion: snapshot.storage.k8s.io/v1
kind: VolumeSnapshot
metadata:
  name: azure-disk-snapshot
spec:
  volumeSnapshotClassName: azure-disk-snapshot-class
  source:
    persistentVolumeClaimName: my-pvc

Restoring from a Snapshot

If you need to restore your data, it’s as simple as creating a new PVC from your snapshot:

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: azure-disk-pvc-restored
spec:
  storageClassName: azure-disk
  dataSource:
    name: azure-disk-snapshot
    kind: VolumeSnapshot
    apiGroup: snapshot.storage.k8s.io
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 10Gi

Advanced Tips and Tricks

Here are a few more cool things you can do with Kubernetes volumes:

Expand Your Storage

Need more space? You can resize your PVCs:

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: my-pvc
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 20Gi
  storageClassName: manual

Choose the Right Access Mode

Different scenarios require different ways of accessing your storage:

ReadWriteOnce (RWO): One node can read and write to the volume.
ReadOnlyMany (ROX): Many nodes can read from the volume, but none can write.
ReadWriteMany (RWX): Multiple nodes can read and write to the volume.

Clean Up with Reclaim Policies

Decide what happens to your PV after you’re done with it:

Retain: Keep the data until you manually clean it up.
Recycle: Wipe the data and make the volume available for someone else.
Delete: Automatically delete the storage when you’re done.

Best Practices

Here are some tips to keep your storage game strong:

Use Dynamic Provisioning: Let Kubernetes handle the heavy lifting by automatically creating storage when needed.
Back Up with Snapshots: Regularly snapshot important data so you can quickly recover if needed.
Monitor Storage Usage: Keep an eye on your PVCs to make sure you don’t run out of space.
Secure Your Data: Use Secrets and ConfigMaps for sensitive info instead of hardcoding it in your app.

Wrapping It Up

Kubernetes volumes give you the power to manage storage in a way that’s flexible, scalable, and easy to use. Whether you’re setting up simple storage for your pods or taking advanced snapshots in Azure, this guide should help you navigate the world of Kubernetes storage with confidence.

Now get out there and start storing like a pro!

Happy clustering!

This content originally appeared on DEV Community and was authored by Hamdi KHELIL