The Ephemeral Data Problem

Look, if you've ever dealt with this in production, you know exactly what the problem is. Throughout this course, we have emphasized that Pods are ephemeral. If a Pod crashes, it is destroyed, and the ReplicaSet creates a brand new clone to replace it. However, this ephemerality extends to the Pod's local filesystem. If you run a PostgreSQL database in a Pod and it saves user data to /var/lib/postgresql/data, that data will be permanently wiped the moment the Pod dies. The new Pod will spin up with an empty database. This makes local storage catastrophic for stateful applications. This isn't just academic theory—understanding the *why* behind this is what separates junior devs from senior engineers. When you deploy to a cluster, this is the mechanic that prevents catastrophic failure.

Look, if you've ever dealt with this in production, you know exactly what the problem is. To solve the data loss problem, Kubernetes decouples storage from compute. It introduces the 'Persistent Volume' (PV). A Persistent Volume is a physical piece of storage infrastructure—like an AWS EBS drive, a Google Persistent Disk, or an NFS share—that exists *outside* of the Pod's lifecycle. Because the PV lives externally, if the Pod dies, the PV remains untouched. When the new Pod spins up, it simply reattaches to the existing PV and resumes exactly where the old Pod left off. This isn't just academic theory—understanding the *why* behind this is what separates junior devs from senior engineers. When you deploy to a cluster, this is the mechanic that prevents catastrophic failure.

Look, if you've ever dealt with this in production, you know exactly what the problem is. However, a developer does not request a Persistent Volume directly. Instead, Kubernetes introduces a middle layer called a 'Persistent Volume Claim' (PVC). Why? Because a developer writing a deployment YAML shouldn't need to know the specific AWS ARN or NFS IP address of the hardware. The developer simply writes a PVC stating: 'I need 10GB of fast storage'. The cluster administrators create a pool of raw PVs. Kubernetes automatically finds a 10GB PV from the pool and 'binds' it to the developer's PVC. This isn't just academic theory—understanding the *why* behind this is what separates junior devs from senior engineers. When you deploy to a cluster, this is the mechanic that prevents catastrophic failure.

Look, if you've ever dealt with this in production, you know exactly what the problem is. Having administrators manually pre-provision dozens of empty 10GB AWS drives just in case a developer needs them is wildly inefficient. Modern Kubernetes solves this with 'StorageClasses'. A StorageClass enables 'Dynamic Provisioning'. When a developer creates a PVC, they specify storageClassName: standard. Kubernetes sees the request, automatically calls the AWS/GCP API, provisions a brand new EBS drive on the fly of the exact requested size, and binds it instantly. No human administrators required. This isn't just academic theory—understanding the *why* behind this is what separates junior devs from senior engineers. When you deploy to a cluster, this is the mechanic that prevents catastrophic failure.

Look, if you've ever dealt with this in production, you know exactly what the problem is. Once the PVC is created and bound to a PV, you must attach it to your Pod. This is done in two steps within the Deployment YAML. First, under the spec.volumes block, you declare the volume and link it to the PVC by name. Second, under the spec.containers.volumeMounts block, you specify exactly where inside the container's filesystem that volume should appear (e.g., /var/lib/mysql). Now, anything the database writes to that folder is actually being written to the external AWS drive. This isn't just academic theory—understanding the *why* behind this is what separates junior devs from senior engineers. When you deploy to a cluster, this is the mechanic that prevents catastrophic failure.

Look, if you've ever dealt with this in production, you know exactly what the problem is. When requesting a PVC, you must define an accessMode. This determines how many nodes can read/write to the volume simultaneously. ReadWriteOnce (RWO) is the most common; it means the volume can only be mounted as read-write by a single Worker Node at a time (standard for databases). ReadWriteMany (RWX) means the volume can be mounted by multiple Worker Nodes simultaneously. Note that standard AWS EBS drives physically do not support RWX; for that, you need a network file system like AWS EFS. This isn't just academic theory—understanding the *why* behind this is what separates junior devs from senior engineers. When you deploy to a cluster, this is the mechanic that prevents catastrophic failure.

Look, if you've ever dealt with this in production, you know exactly what the problem is. You have now bridged the gap between stateless compute and stateful data. By utilizing Persistent Volumes (PV), Persistent Volume Claims (PVC), and StorageClasses, you can deploy enterprise-grade databases inside Kubernetes with complete confidence that data will survive pod crashes and node failures. However, application configuration data (like database connection strings) should not be hardcoded into images or stored on PVs. Next, we will explore ConfigMaps and Secrets. This isn't just academic theory—understanding the *why* behind this is what separates junior devs from senior engineers. When you deploy to a cluster, this is the mechanic that prevents catastrophic failure.

The Ephemeral Data Problem. Throughout this course, we have emphasized that Pods are ephemeral. If a Pod crashes, it is destroyed, and the ReplicaSet creates a brand new clone to replace it. However, this ephemerality extends to the Pod's local filesystem. If you run a PostgreSQL database in a Pod and it saves user data to /var/lib/postgresql/data, that data will be permanently wiped the moment the Pod dies. The new Pod will spin up with an empty database. This makes local storage catastrophic for stateful applications.

Persistent Volumes (PV). To solve the data loss problem, Kubernetes decouples storage from compute. It introduces the 'Persistent Volume' (PV). A Persistent Volume is a physical piece of storage infrastructure—like an AWS EBS drive, a Google Persistent Disk, or an NFS share—that exists *outside* of the Pod's lifecycle. Because the PV lives externally, if the Pod dies, the PV remains untouched. When the new Pod spins up, it simply reattaches to the existing PV and resumes exactly where the old Pod left off.

You are designing an architecture for a stateful MySQL database in Kubernetes. To ensure the database tables are not deleted when the MySQL pod is restarted, what Kubernetes abstraction must you use?

• →Mount a Persistent Volume (PV).
• →Configure the ReplicaSet to never restart.

The Persistent Volume Claim (PVC). However, a developer does not request a Persistent Volume directly. Instead, Kubernetes introduces a middle layer called a 'Persistent Volume Claim' (PVC). Why? Because a developer writing a deployment YAML shouldn't need to know the specific AWS ARN or NFS IP address of the hardware. The developer simply writes a PVC stating: 'I need 10GB of fast storage'. The cluster administrators create a pool of raw PVs. Kubernetes automatically finds a 10GB PV from the pool and 'binds' it to the developer's PVC.

Storage Classes (Dynamic Provisioning). Having administrators manually pre-provision dozens of empty 10GB AWS drives just in case a developer needs them is wildly inefficient. Modern Kubernetes solves this with 'StorageClasses'. A StorageClass enables 'Dynamic Provisioning'. When a developer creates a PVC, they specify storageClassName: standard. Kubernetes sees the request, automatically calls the AWS/GCP API, provisions a brand new EBS drive on the fly of the exact requested size, and binds it instantly. No human administrators required.

What is the primary benefit of using a StorageClass in your Kubernetes cluster?

• →It enables Dynamic Provisioning of storage hardware.
• →It encrypts data automatically.

Mounting the Volume to the Pod. Once the PVC is created and bound to a PV, you must attach it to your Pod. This is done in two steps within the Deployment YAML. First, under the spec.volumes block, you declare the volume and link it to the PVC by name. Second, under the spec.containers.volumeMounts block, you specify exactly where inside the container's filesystem that volume should appear (e.g., /var/lib/mysql). Now, anything the database writes to that folder is actually being written to the external AWS drive.

Access Modes. When requesting a PVC, you must define an accessMode. This determines how many nodes can read/write to the volume simultaneously. ReadWriteOnce (RWO) is the most common; it means the volume can only be mounted as read-write by a single Worker Node at a time (standard for databases). ReadWriteMany (RWX) means the volume can be mounted by multiple Worker Nodes simultaneously. Note that standard AWS EBS drives physically do not support RWX; for that, you need a network file system like AWS EFS.

You are deploying a web application where 5 separate Pods running on 5 separate Nodes must all be able to upload and modify images in the exact same shared /assets folder simultaneously. Which Access Mode is required?

• →ReadWriteMany (RWX)
• →ReadWriteOnce (RWO)

Conclusion of Storage. You have now bridged the gap between stateless compute and stateful data. By utilizing Persistent Volumes (PV), Persistent Volume Claims (PVC), and StorageClasses, you can deploy enterprise-grade databases inside Kubernetes with complete confidence that data will survive pod crashes and node failures. However, application configuration data (like database connection strings) should not be hardcoded into images or stored on PVs. Next, we will explore ConfigMaps and Secrets.