When working with cloud platforms such as AWS, Azure, or Google Cloud, you'll encounter several different types of storage. The three fundamental categories are:

1. Block storage
2. File storage
3. Object storage

Understanding the difference between them is important when working with VMs, databases, Kubernetes, backups, and cloud architectures.

1. Block Storage

Block storage is the closest equivalent to a physical hard disk or SSD.

The cloud provider gives your VM a virtual disk, and the operating system sees it as a block device.

Cloud
  │
  └── 50 GB Block Disk
          │
          ↓
        VM
          │
       /dev/sdb
          │
       filesystem
          │
        /data

For example, in Linux:

lsblk

might show:

NAME   SIZE
sda     64G
sdb     50G

You can create a filesystem:

sudo mkfs.ext4 /dev/sdb

and mount it:

sudo mkdir /data
sudo mount /dev/sdb /data

Now the disk behaves much like a physical disk attached to the machine.

Examples

Typical use cases

• VM operating systems
• PostgreSQL/MySQL databases
• Application data
• Kubernetes persistent volumes
• High-performance workloads

2. Object Storage

Object storage works very differently.

Instead of giving you a disk, the cloud provider gives you a storage service accessed through APIs.

The most famous example is Amazon S3.

Application
     │
     │ HTTP / API
     ↓
 Object Storage
     │
     ├── image.jpg
     ├── backup.tar
     ├── data.csv
     └── logs/

You don't normally get something like:

/dev/sdb

Instead, you interact with objects using APIs, SDKs, CLI tools, or HTTP.

For example, conceptually:

bucket: my-backups
object: database/backup.sql

Examples

Typical use cases

• Backups
• Images and videos
• Logs
• Data lakes
• Large files
• Static website assets
• Machine-learning datasets

Why is it popular?

Object storage is designed to scale to enormous amounts of data and is generally very durable.

You don't have to think about:

/dev/sdb
filesystem
partitions
mount points

You simply store and retrieve objects.

3. File Storage

File storage provides a filesystem over the network.

The cloud provider manages the filesystem, and your machines connect to it.

                 File Storage
                     │
             ┌───────┼───────┐
             │       │       │
            VM1     VM2     VM3
             │       │       │
          /shared  /shared  /shared

Multiple machines can access the same files.

Common protocols include:

• NFS — Network File System
• SMB — Server Message Block

For example, with NFS:

sudo mount -t nfs server:/data /mnt/data

The remote filesystem then appears locally:

ls /mnt/data

Examples

Typical use cases

• Shared application files
• Shared configuration
• Multiple VMs accessing the same data
• Kubernetes volumes requiring shared access
• Enterprise applications

4. NFS Is a Protocol, Not a Storage Type

This is an important distinction.

NFS means Network File System.

It is a protocol for accessing a filesystem over a network.

For example:

              NFS
               │
               ↓
        Network filesystem
               │
        ┌──────┼──────┐
        ↓      ↓      ↓
       VM1    VM2    VM3

So don't think:

NFS = a type of disk.

Instead:

NFS = a way of accessing file storage over a network.

Similarly, SMB is another protocol commonly used for network file storage.

5. Comparing the Three

6. The Easiest Mental Model

Think about a normal physical computer.

Block storage

You buy a hard drive:

500 GB SSD
     ↓
Computer
     ↓
/dev/sdb
     ↓
ext4
     ↓
/data

Cloud block storage is essentially a virtualized version of this concept.

File storage

Think about a NAS in your office:

                 NAS
                  │
        ┌─────────┼─────────┐
        ↓         ↓         ↓
       PC1       PC2       PC3

Everyone accesses the same shared filesystem.

Cloud file storage provides a similar concept as a managed service.

Object storage

Think about Google Drive/S3-style storage:

Bucket
├── photo.jpg
├── backup.zip
├── video.mp4
└── dataset.csv

Applications access the objects through an API rather than treating the storage as a normal disk.

7. What About SSD vs HDD?

This is a different dimension.

You can have different performance classes within block storage:

Block Storage
    │
    ├── HDD
    ├── Standard SSD
    ├── Premium SSD
    └── High-performance SSD

The important characteristics are typically:

• Capacity
• IOPS
• Throughput
• Latency
• Durability
• Cost

For example, a PostgreSQL database usually cares a lot about IOPS and latency, while a large backup archive may care more about capacity and cost.

8. What About Snapshots and Backups?

Snapshots and backups aren't really a fourth fundamental storage category.

For example:

Managed Disk
     │
     ├── Snapshot — Monday
     ├── Snapshot — Tuesday
     └── Snapshot — Wednesday

A snapshot is a point-in-time copy/state of storage.

You can often use a snapshot to create a new disk:

Snapshot
    ↓
New Managed Disk
    ↓
Attach to VM
    ↓
Mount filesystem
    ↓
Access files

This is useful when recovering data from a VM.

9. Kubernetes Connection

These concepts become especially useful with Kubernetes.

A Kubernetes application might request storage using a PersistentVolumeClaim:

Pod
 │
 ↓
PersistentVolumeClaim
 │
 ↓
PersistentVolume
 │
 ↓
Cloud Storage

The underlying storage might be:

PVC
 ↓
Azure Managed Disk

or:

PVC
 ↓
Azure Files

The distinction matters because block storage and file storage have different sharing characteristics.

For example, a block-backed volume may typically be attached to one node, while a network file system can allow multiple nodes to access the same filesystem.

10. Summary

The three concepts to remember are:

┌───────────────────────────────────────────┐
│                BLOCK                      │
│                                           │
│ "Give me a disk."                         │
│                                           │
│ /dev/sdb → filesystem → /data             │
└───────────────────────────────────────────┘

┌───────────────────────────────────────────┐
│                 FILE                      │
│                                           │
│ "Give me a shared filesystem."            │
│                                           │
│ NFS / SMB → /mnt/shared                   │
└───────────────────────────────────────────┘

┌───────────────────────────────────────────┐
│                OBJECT                     │
│                                           │
│ "Give me scalable storage through API."   │
│                                           │
│ Bucket → Object → API/HTTP                │
└───────────────────────────────────────────┘

In one sentence:

Block storage is a virtual disk, file storage is a shared network filesystem, and object storage is an API-accessible store for objects such as files and backups.