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:
- Block storage
- File storage
- 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
| Cloud | Block storage |
|---|---|
| AWS | Amazon EBS |
| Azure | Azure Managed Disks |
| Google Cloud | Persistent Disk / Hyperdisk |
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
| Cloud | Object storage |
|---|---|
| AWS | Amazon S3 |
| Azure | Azure Blob Storage |
| Google Cloud | Cloud Storage |
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
| Cloud | File storage |
|---|---|
| AWS | Amazon EFS / FSx |
| Azure | Azure Files / Azure NetApp Files |
| Google Cloud | Filestore / NetApp Volumes |
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
| Block | File | Object | |
|---|---|---|---|
| Mental model | Virtual disk | Network filesystem | S3-like bucket |
| Access | Block device | NFS / SMB | API / HTTP |
| Appears as | /dev/sdb |
/mnt/shared |
Bucket + object key |
| Filesystem | You manage it | Provider manages it | Not a traditional filesystem |
| Mountable | Yes | Yes | Not normally |
| Shared by VMs | Limited/depends on service | Yes | Yes |
| Typical use | Databases, VMs | Shared files | Backups, images, data |
| AWS | EBS | EFS / FSx | S3 |
| Azure | Managed Disks | Azure Files | Blob Storage |
| GCP | Persistent Disk | Filestore | Cloud Storage |
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.
Top comments (0)