Access modes (ReadWriteOnce, ReadOnlyMany, ReadWriteMany) in Kubernetes - Mini Project: Build & Apply

Understanding Kubernetes Persistent Volume Access Modes

📖 Scenario: You are setting up storage for a Kubernetes application. You need to understand how different access modes control how pods can use the storage.Access modes define if the storage can be read or written by one or many pods at the same time.

🎯 Goal: Learn to create a PersistentVolumeClaim (PVC) with different access modes: ReadWriteOnce, ReadOnlyMany, and ReadWriteMany.You will write YAML snippets to define PVCs with these access modes and see how they affect pod access.

📋 What You'll Learn

Create a PersistentVolumeClaim YAML with ReadWriteOnce access mode

Add a PVC YAML with ReadOnlyMany access mode

Create a PVC YAML with ReadWriteMany access mode

Print the access modes of each PVC to verify

💡 Why This Matters

🌍 Real World

Kubernetes applications often need persistent storage. Understanding access modes helps ensure data is shared correctly and safely among pods.

💼 Career

DevOps engineers and Kubernetes administrators must configure storage access modes to meet application requirements and avoid data corruption.

1

Create a PersistentVolumeClaim with ReadWriteOnce access mode

Create a YAML string variable called pvc_rwo that defines a PersistentVolumeClaim with accessModes set to ["ReadWriteOnce"]. Use storage: 1Gi under resources.requests.

Kubernetes

# Create pvc_rwo YAML string with accessModes: ["ReadWriteOnce"] and storage 1Gi
# Your code here

Hint

Remember to use a multi-line string with triple quotes and indent YAML properly.

2

Add a PersistentVolumeClaim with ReadOnlyMany access mode

Create a YAML string variable called pvc_rom that defines a PersistentVolumeClaim with accessModes set to ["ReadOnlyMany"]. Use storage: 2Gi under resources.requests.

Kubernetes

pvc_rwo = """
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: pvc-rwo
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 1Gi
"""
# Create pvc_rom YAML string with accessModes: ["ReadOnlyMany"] and storage 2Gi
# Your code here

Hint

Follow the same YAML structure as the first PVC but change the access mode and storage size.

3

Create a PersistentVolumeClaim with ReadWriteMany access mode

Create a YAML string variable called pvc_rwm that defines a PersistentVolumeClaim with accessModes set to ["ReadWriteMany"]. Use storage: 3Gi under resources.requests.

Kubernetes

pvc_rwo = """
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: pvc-rwo
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 1Gi
"""

pvc_rom = """
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: pvc-rom
spec:
  accessModes:
    - ReadOnlyMany
  resources:
    requests:
      storage: 2Gi
"""
# Create pvc_rwm YAML string with accessModes: ["ReadWriteMany"] and storage 3Gi
# Your code here

Hint

Use the same pattern as before but set accessModes to ReadWriteMany and storage to 3Gi.

4

Print the access modes of each PersistentVolumeClaim

Write three print statements to display the access modes of pvc_rwo, pvc_rom, and pvc_rwm. Extract the access mode line from each YAML string and print it exactly as Access mode: ReadWriteOnce, Access mode: ReadOnlyMany, and Access mode: ReadWriteMany respectively.

Kubernetes

pvc_rwo = """
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: pvc-rwo
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 1Gi
"""

pvc_rom = """
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: pvc-rom
spec:
  accessModes:
    - ReadOnlyMany
  resources:
    requests:
      storage: 2Gi
"""

pvc_rwm = """
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: pvc-rwm
spec:
  accessModes:
    - ReadWriteMany
  resources:
    requests:
      storage: 3Gi
"""
# Print the access modes of pvc_rwo, pvc_rom, and pvc_rwm
# Your code here

Hint

Print the exact lines as shown, one per PVC.

Practice

1. Which Kubernetes access mode allows a volume to be mounted as read-write by only one node at a time?

easy

A. ReadWriteOnce

B. ReadOnlyMany

C. ReadWriteMany

D. ReadWriteAll

Solution

1. Step 1: Understand ReadWriteOnce meaning

   ReadWriteOnce means the volume can be mounted as read-write by a single node only.

2. Step 2: Compare with other modes

   ReadOnlyMany allows multiple nodes but only read access; ReadWriteMany allows multiple nodes with read-write access.

3. Final Answer:

   ReadWriteOnce -> Option A

4. Quick Check:

   Single writer = ReadWriteOnce [OK]

Hint: Single writer means ReadWriteOnce [OK]

Common Mistakes:

• Confusing ReadWriteOnce with ReadWriteMany
• Thinking ReadOnlyMany allows write access
• Assuming ReadWriteAll is a valid mode

2. Which of the following is the correct YAML snippet to specify a volume with ReadOnlyMany access mode?

easy

A. accessModes:
- ReadWriteOnce

B. accessModes:
- ReadWriteMany

C. accessModes:
- ReadOnlyMany

D. accessModes:
- ReadOnlyOnce

Solution

1. Step 1: Identify correct access mode syntax

   The accessModes field is a list with valid values: ReadWriteOnce, ReadOnlyMany, ReadWriteMany.

2. Step 2: Match ReadOnlyMany exactly

   accessModes: - ReadOnlyMany correctly uses "ReadOnlyMany" as the access mode in YAML format.

3. Final Answer:

   accessModes:\n - ReadOnlyMany -> Option C

4. Quick Check:

   YAML list with ReadOnlyMany is correct [OK]

Hint: YAML list with dash and correct mode name [OK]

Common Mistakes:

• Using invalid mode ReadOnlyOnce
• Missing dash before access mode
• Using ReadWriteOnce instead of ReadOnlyMany

3. Given a PersistentVolumeClaim with accessModes set to [ReadWriteMany], what will happen if two pods on different nodes try to write to the volume simultaneously?

medium

A. Pods can only read, not write to the volume.

B. Only one pod can write; the other will get a write error.

C. The volume will be mounted read-only on both pods.

D. Both pods can write to the volume at the same time without issues.

Solution

1. Step 1: Understand ReadWriteMany behavior

   ReadWriteMany allows multiple nodes to mount the volume with read-write access simultaneously.

2. Step 2: Apply to pods on different nodes

   Since both pods are on different nodes, they can both write to the volume at the same time without conflict.

3. Final Answer:

   Both pods can write to the volume at the same time without issues. -> Option D

4. Quick Check:

   ReadWriteMany = multiple writers allowed [OK]

Hint: ReadWriteMany means multiple writers allowed [OK]

Common Mistakes:

• Assuming only one writer allowed with ReadWriteMany
• Confusing ReadOnlyMany with ReadWriteMany
• Thinking volume becomes read-only automatically

4. You have a PersistentVolumeClaim with accessModes set to ReadWriteOnce. You try to mount it as read-write on two pods running on different nodes. What is the likely outcome?

medium

A. Both pods mount the volume read-write successfully.

B. Only one pod mounts the volume read-write; the other fails to mount.

C. Both pods mount the volume read-only.

D. Both pods fail to mount the volume.

Solution

1. Step 1: Recall ReadWriteOnce limitation

   ReadWriteOnce allows only one node to mount the volume as read-write at a time.

2. Step 2: Analyze mounting on two nodes

   Since pods are on different nodes, only one pod can mount read-write; the other pod's mount will fail.

3. Final Answer:

   Only one pod mounts the volume read-write; the other fails to mount. -> Option B

4. Quick Check:

   ReadWriteOnce = single node writer [OK]

Hint: ReadWriteOnce limits to one node writer [OK]

Common Mistakes:

• Assuming both pods can mount read-write
• Thinking volume auto-switches to read-only
• Believing both pods fail to mount

5. You need to design a shared storage solution for a Kubernetes cluster where multiple pods across different nodes must read and write data simultaneously. Which access mode should you choose and why?

hard

A. ReadWriteMany, because it allows multiple pods on different nodes to read and write simultaneously.

B. ReadOnlyMany, because it allows multiple pods to write simultaneously.

C. ReadWriteOnce, because it supports multiple writers on different nodes.

D. ReadWriteOnce, because it allows multiple pods to read-only mount the volume.

Solution

1. Step 1: Identify requirement for multiple writers on different nodes

   The requirement is for multiple pods on different nodes to read and write simultaneously.

2. Step 2: Match access mode to requirement

   ReadWriteMany allows multiple nodes to mount the volume with read-write access at the same time, fulfilling the requirement.

3. Final Answer:

   ReadWriteMany, because it allows multiple pods on different nodes to read and write simultaneously. -> Option A

4. Quick Check:

   Shared read-write = ReadWriteMany [OK]

Hint: Multiple writers/readers need ReadWriteMany [OK]

Common Mistakes:

• Choosing ReadWriteOnce for multi-node writes
• Confusing ReadOnlyMany as write-capable
• Misunderstanding access mode capabilities