Hubbry Logo
Block-level storageBlock-level storageMain
Open search
Block-level storage
Community hub
Block-level storage
logo
7 pages, 0 posts
0 subscribers
Be the first to start a discussion here.
Be the first to start a discussion here.
Block-level storage
Block-level storage
Block-level storage
View on Wikipedia
from Wikipedia

Block-level storage is a concept in cloud-hosted data persistence where cloud services emulate the behaviour of a traditional block device, such as a physical hard drive.[1]

Storage in such services is organised as blocks. This emulates the type of behaviour seen in traditional disks or tape storage through storage virtualization. Blocks are identified by an arbitrary and assigned identifier by which they may be stored and retrieved, but this has no obvious meaning in terms of files or documents. A file system must be applied on top of the block-level storage to map 'files' onto a sequence of blocks.

Amazon EBS (elastic block store) is an example of a cloud block store.[2] Cloud block-level storage will usually offer facilities such as replication for reliability, or backup services.[3]

Block-level storage is in contrast to an object store or 'bucket store', such as Amazon S3 (simple storage service), or to a database. These operate at a higher level of abstraction and are able to work with entities such as files, documents, images, videos or database records.[4]

Instance stores are another form of cloud-hosted block-level storage. These are provided as part of an 'instance', such as an Amazon EC2 (elastic compute cloud) service.[5] As EC2 instances are primarily provided as compute resources, rather than storage resources, their storage is less robust. Their contents will be lost if the cloud instance is stopped.[6] As these stores are part of the instance's virtual server they offer higher performance and bandwidth to the instance. They are best used for temporary storage such as caching or temporary files, with persistent storage held on a different type of server.

At one time, block-level storage was provided by storage area networks (SAN) and NAS provided file-level storage.[7] With the shift from on-premises hosting to cloud services, this distinction has shifted.[8] Even block-storage is now seen as distinct servers (thus NAS), rather than the previous array of bare disks.

See also

[edit]

References

[edit]
Revisions and contributorsEdit on WikipediaRead on Wikipedia

Block-level storage

View on Grokipedia
from Grokipedia
Block-level storage, also known as block storage, is a data storage architecture that organizes information into fixed-size blocks, each assigned a unique identifier for direct access and management, commonly deployed in storage area networks (SANs), cloud environments, and virtualized systems to enable high-performance operations. This approach treats storage as raw volumes presented to servers or applications, allowing the operating system or software to handle file systems independently on top of the blocks, which facilitates efficient read/write operations without the overhead of hierarchical file structures. In block-level storage, data is divided into equally sized blocks—typically ranging from a few kilobytes to several megabytes—stored independently across hardware or , and retrieved via a or address system that reassembles them as needed. This low-level provides hardware , supporting multiple operating systems and enabling by adding volumes dynamically, making it ideal for demanding workloads such as , virtual machines, and containerized applications that require low latency and high input/output operations per second (). Key advantages of block-level storage include superior performance due to multiple access paths and direct block-level I/O, flexibility in partitioning across environments, and reliability when combined with technologies like RAID for redundancy, though it lacks built-in extensive metadata support, which is managed at the application layer. Compared to file-level storage (NAS), which uses hierarchical directories and is better for shared file access but slower due to single-path dependencies, block storage offers faster retrieval for structured data but is less suited for collaborative environments. In contrast to object storage, which stores data as discrete objects with rich, customizable metadata for unstructured files like backups or media, block storage excels in transactional scenarios but can be more expensive and less scalable for massive, infrequently accessed datasets. Block-level storage has become foundational in modern , powering services like Block Storage as a Service (BaaS) in public clouds from providers such as AWS, Azure, and Google Cloud, as well as enterprise solutions integrated with platforms like . Despite its strengths, challenges include higher costs relative to and the need for additional layers to handle redundancy or metadata, positioning it as a preferred for performance-critical infrastructure in data centers and hybrid s.

Fundamentals

Definition

Block-level storage is a method of storing data in fixed-size contiguous blocks, typically ranging from 512 bytes to 4 KB or larger, where the data is treated as raw storage without any inherent structure. Each block operates independently and is assigned a , allowing the storage system to manage and retrieve data efficiently at a low level close to the hardware. In this storage model, data is accessed through arbitrary byte offsets that map to specific blocks, enabling direct read and write operations without navigating a hierarchical file structure. However, practical organization of these blocks into files and directories requires an overlay , such as for Windows or for , which interprets the raw blocks and provides user-friendly abstraction. Blocks in block-level storage represent the smallest addressable unit of data, emulating the sectors found on physical disk devices and distinguishing this approach from raw, unformatted device access. For instance, a (HDD) or (SSD) presents its capacity as a linear sequence of such blocks to the operating system.

Key Characteristics

Block-level storage utilizes fixed-size blocks, commonly 512 bytes to 64 KB depending on the , which enable efficient to data portions independent of file boundaries. This structure supports low-latency read and write operations by allowing direct manipulation of individual blocks without needing to traverse hierarchical file structures. A core feature is the (LBA) scheme, which assigns a unique sequential identifier to each block for precise, direct access across the storage medium. This addressing method abstracts the physical layout of the storage device, facilitating reliable data retrieval and modification at the block level. File systems built atop block-level storage exhibit statefulness in their operational model, necessitating the maintenance of metadata to preserve data consistency, especially in scenarios involving interruptions like system crashes. These file systems commonly employ journaling techniques to log metadata changes, ensuring atomic updates and rapid recovery without full rescans. Performance scalability in block-level storage is constrained by key metrics such as operations per second () for and throughput for data transfer rates, both of which are significantly influenced by block size selection. Smaller blocks maximize for fine-grained operations, while larger blocks minimize overhead in sequential workloads, enhancing overall throughput efficiency. File systems provide a higher-level abstraction by mapping these addressable blocks into organized files and directories for user applications.

Comparisons with Other Storage Types

Versus File-Level Storage

Block-level storage operates at the raw data layer, where data is stored and accessed in fixed-size blocks with unique identifiers, providing low-level control without inherent abstraction. In contrast, file-level storage organizes data into hierarchical structures of files and directories, allowing direct access via file paths and abstracting away the underlying block management through a . This in file-level storage is facilitated by protocols such as NFS for Unix/ environments or SMB for Windows systems, enabling seamless over networks. Regarding access granularity, block-level storage treats data as undifferentiated blocks, requiring users or applications to mount a file system—such as or —on the storage volume to perform file-level operations like reading or writing specific files. File-level storage, however, natively manages file naming, permissions, and sharing mechanisms at the protocol level, simplifying access without needing additional layers. This difference means block-level storage offers greater flexibility in how blocks are addressed and assembled but demands more configuration for end-user file interactions. Historically, block-level storage has been implemented through Storage Area Networks (SANs), which provide dedicated, high-speed networks for block access, emerging in the to support enterprise data centers requiring raw performance. File-level storage, on the other hand, is typically delivered via appliances, which integrate file system services and became popular for collaborative environments in the same era, prioritizing ease of over low-level control. In terms of performance trade-offs, block-level storage delivers lower latency and higher throughput for workloads involving frequent random reads and writes, such as databases or virtual machines, due to its direct block addressing and multiple concurrent data paths. File-level storage excels in simplicity for shared file access scenarios, like document , but can introduce overhead from file system metadata management, making it less efficient for latency-sensitive applications.

Versus Object Storage

Block-level storage organizes data into fixed-size blocks arranged in a flat array, enabling direct positional access to any block via unique identifiers, which allows for efficient random read and write operations. In contrast, object storage treats data as discrete, immutable objects, each comprising the data itself, a (such as a key), and associated rich metadata, with access typically facilitated through HTTP-based protocols like APIs. This structural difference means block-level storage supports low-level, byte-addressable operations suitable for applications requiring frequent modifications, while emphasizes holistic object retrieval and is less suited for in-place edits. Scalability models diverge significantly between the two paradigms. Block-level storage primarily scales vertically by expanding the capacity or of individual volumes, which is effective for structured workloads but can introduce bottlenecks in highly distributed environments. , however, excels in horizontal , distributing objects across numerous nodes in a cluster to handle exabyte-scale datasets without a central point of failure, making it ideal for massive, infrequently accessed archives. For instance, fixed block sizes in block-level systems, typically ranging from 512 bytes to 4 MB depending on the , facilitate this vertical growth but limit seamless expansion compared to object storage's flexible, metadata-driven partitioning. At the , block-level storage requires an overlying or database to impose hierarchical organization and manage semantics, providing a raw, unstructured foundation for operating systems and applications. operates in a schemaless manner, bypassing traditional file hierarchies in favor of a flat where objects are addressed directly by ID, which suits such as media files, logs, or backups that benefit from embedded metadata for search and retrieval. This makes particularly advantageous for modern distributed systems handling diverse, non-relational without the overhead of maintenance. Practical examples illustrate these distinctions in cloud environments. Amazon Elastic Block Store (EBS) exemplifies block-level storage, offering persistent volumes attachable to EC2 instances for database hosting, where blocks can be updated partially to support transactional integrity. Conversely, Amazon Simple Storage Service (S3) represents , storing files as immutable objects that cannot be partially updated—instead requiring full object replacement—which prioritizes durability and global accessibility over fine-grained modifications.

Technical Implementation

Block Devices and Access Protocols

Block devices serve as logical abstractions in operating systems that represent storage hardware accessible in fixed-size blocks, allowing applications to perform read and write operations as if interacting with a raw disk. In , for instance, these are typically exposed as device files such as /dev/sda, which emulates a or ATA disk and supports commands for block-level I/O through the kernel's block layer. Key protocols enable the transport of these block-level commands across various interfaces. The iSCSI protocol, standardized by the IETF, provides IP-based access to block storage over Ethernet networks by encapsulating SCSI commands within TCP/IP packets, allowing initiators to connect to remote targets for seamless block I/O. Fibre Channel, developed as a high-speed serial protocol for storage area networks (SANs), facilitates low-latency, high-throughput block access in fabric topologies, supporting distances up to hundreds of kilometers via fiber optics and enabling switched interconnects for multiple hosts and storage arrays. NVMe, an optimized protocol from the NVM Express consortium, delivers low-latency access to SSDs over the PCIe bus, leveraging parallel command queues and reducing overhead compared to legacy protocols like SCSI, with support for up to 65,535 queues and 64,000 commands per queue. Access to block devices occurs through direct or networked methods. Direct Attached Storage (DAS) connects storage directly to a host via local interfaces like , SAS, or PCIe, providing high-performance, low-latency block access without network intermediaries, ideal for single-host environments. In networked setups, such as SANs, access is mediated by Logical Unit Numbers (LUNs), where LUN masking at the storage controller or host bus level restricts visibility and access to specific LUNs, ensuring secure isolation for virtualized hosts by mapping only authorized initiators to target volumes. Modern extensions like NVMe over Fabrics (NVMe-oF) extend NVMe's efficiency to remote block access over network fabrics, supporting transports such as RDMA to minimize CPU involvement and latency, enabling disaggregated storage pools with approaching local PCIe attachments.

Management and Operations

Volume management in block-level storage involves tools that abstract physical devices into flexible logical units, enabling dynamic allocation and reconfiguration. The Logical Volume Manager (LVM) in systems serves as a primary tool for this purpose, allowing administrators to create, resize, stripe data across multiple devices for performance, and mirror volumes for redundancy without disrupting ongoing operations. LVM achieves this by layering logical volumes over physical extents, which can be adjusted online to accommodate growing data needs or hardware changes. Data operations in block-level storage facilitate efficient handling of volumes through mechanisms like snapshots, cloning, and thin provisioning. Snapshots create point-in-time copies using copy-on-write (CoW), where unchanged data blocks remain shared between the original volume and snapshot, and only modified blocks are duplicated to minimize storage overhead. Cloning produces a writable duplicate of a volume, often leveraging snapshot technology in systems like LVM to enable rapid replication for testing or development without full data copying upfront. Thin provisioning allocates storage on-demand, presenting larger virtual volumes to applications while consuming physical space only as data is written, thus optimizing resource utilization in environments with variable workloads. Error handling at the block level commonly integrates configurations to provide and data protection. 0 employs striping to distribute data across drives for enhanced performance but offers no redundancy, making it suitable for non-critical, high-speed applications. In contrast, 5 uses distributed parity across multiple drives to enable recovery from a single drive failure, balancing capacity, performance, and reliability by calculating parity blocks to reconstruct lost data. These levels are implemented via software tools like in , which manage array assembly, monitoring, and rebuilding to maintain during hardware faults. Backup strategies for block-level storage emphasize capturing raw volumes to ensure comprehensive preservation and rapid recovery. Block-level backups copy the entire volume at the level, bypassing file systems to include all , metadata, and boot configurations, which supports bare-metal restores that rebuild systems from scratch on new hardware. This approach accelerates recovery by restoring volumes directly, enabling operating systems and applications to without additional reconfiguration, particularly in disaster scenarios. Tools like in or commercial solutions facilitate these raw backups, ensuring fidelity to the original storage state.

Applications and Use Cases

In On-Premises Environments

In on-premises environments, block-level storage is widely deployed for hosting high-performance databases such as and , where low-latency access and high are essential for and data-intensive workloads. These systems treat storage as raw blocks, enabling direct, efficient I/O operations that support the demanding requirements of (OLTP) applications. For instance, databases leverage block storage to achieve up to 99.9999% availability and significantly faster backups, reducing project delivery times by up to 30%. Similarly, deployments benefit from block storage's ability to handle concurrent reads and writes with minimal overhead, ensuring consistent performance in enterprise settings. Virtualization platforms like further exemplify block-level storage's role in on-premises setups, where it functions as the foundation for (VM) disks. Virtual disks, often provisioned as VMDKs on VMFS datastores, provide scalable block access for VMs running database instances, allowing multiple virtualized servers to share underlying physical storage resources without performance degradation. Best practices recommend using paravirtualized adapters and eager zeroed thick provisioning for I/O-intensive workloads to optimize throughput and reduce latency. This configuration supports database consolidation, enabling efficient resource utilization across physical hosts in data centers. Enterprise on-premises infrastructures commonly utilize (SAN) arrays from vendors such as Dell EMC and to deliver shared block storage accessible by multiple servers via protocols like or . These SAN systems centralize block-level data in a pooled environment, facilitating high-availability clustering and seamless for mission-critical applications. NetApp's ONTAP-based SAN solutions, for example, guarantee 100% data availability and support unified management for block workloads, ensuring operational continuity. To enhance performance, on-premises block storage often incorporates SSD caching tiers to accelerate access to frequently used "hot" data, while hybrid arrays blend HDDs for cost-effective capacity with flash storage for speed. systems exemplify this approach, combining hybrid flash with HDD tiers to balance demands and storage economics in SAN deployments. Security is bolstered through block-level encryption, such as integrated with LUKS in environments, which protects data at rest on entire block devices using strong ciphers like AES-XTS. Redundancy is typically achieved via configurations within these arrays to mitigate hardware failures.

In Cloud and Virtualized Systems

In cloud environments, block-level storage is commonly provided as persistent volumes that can be dynamically attached to virtual machines (VMs), enabling scalable and flexible data management. Amazon Elastic Block Store (EBS) offers durable block storage volumes that attach to EC2 instances, functioning like physical hard drives, with support for elastic volume modifications to increase capacity or adjust performance without downtime. Similarly, Google Cloud Persistent Disk provides high-performance block storage for Compute Engine VMs, allowing dynamic resizing and integration with various instance types for workloads requiring low-latency access. Azure Managed Disks serve as block-level volumes for Azure VMs, supporting scalability up to 50,000 disks per subscription per region and offering performance tiers like Premium SSD for IO-intensive applications. In virtualized systems, block-level storage integrates seamlessly at the level to abstract physical resources for guest operating systems. For instance, uses VMDK (Virtual Machine Disk) files to represent virtual block devices, storing data on underlying block storage while supporting features like snapshots and for efficient resource utilization in virtualized data centers. Cloud providers enhance this with high-availability options, such as EBS volumes that automatically replicate data across multiple servers within an Availability Zone (AZ) with up to 99.999% durability for high-endurance types like io2 Block Express, or Google Cloud's Regional Persistent Disks, which synchronously replicate data across two zones in a region to withstand zonal failures. Azure's zone-redundant storage (ZRS) for managed disks synchronously replicates across three AZs, achieving 99.9999999999% (12 nines) durability and enabling recovery from zone outages by force-detaching and reattaching disks. Key features include automated backups and ephemeral options for performance-sensitive tasks. EBS snapshots create point-in-time, incremental backups stored durably in , which can be automated via Amazon Data Lifecycle Manager for retention policies up to years. Google Persistent Disk supports snapshots for backups, while Azure Managed Disks integrate with Azure Backup for automated protection. For ephemeral high-performance needs, AWS EC2 instance stores provide temporary block storage physically attached to the host, ideal for caches or scratch but lost upon instance stop or termination, contrasting with persistent volumes like EBS. Modern trends emphasize dynamic provisioning in containerized environments, where uses Container Storage Interface (CSI) drivers to automatically create and manage block storage volumes. A PersistentVolumeClaim (PVC) triggers the CSI driver to provision a raw block device based on a StorageClass, supporting expansion and attachment to pods in architectures for stateful applications. This enables elastic scaling in orchestrators like Kubernetes Engine or Azure Kubernetes Service, where CSI integrates with underlying cloud block storage for seamless, on-demand allocation.

Advantages and Disadvantages

Benefits

Block-level storage provides high performance through its low-level access mechanism, which delivers superior input/output operations per second () and throughput, making it particularly suitable for transactional workloads such as that require rapid read and write operations. This direct block-level interface minimizes overhead compared to higher-level abstractions, enabling low latency for applications demanding consistent and fast data access. A key advantage is its flexibility, allowing entire storage volumes to be easily migrated between different systems or environments without significant reconfiguration, as blocks can be rerouted simply by updating the destination path. Furthermore, block-level storage supports a wide range of file systems and operating systems without being locked into specific protocols, facilitating seamless integration across diverse infrastructures. Efficiency is enhanced by features like , which allocates storage on demand rather than reserving it upfront, thereby optimizing resource utilization and reducing waste in dynamic environments. Snapshots further contribute to by creating point-in-time copies of volumes with minimal additional storage overhead, as they reference existing data blocks, which minimizes during backups and supports quick recovery operations. Block-level storage offers strong compatibility by emulating physical disk devices, which simplifies the integration of legacy applications in virtualized or environments, treating volumes as standard block devices accessible via protocols like or [Fibre Channel](/page/Fibre Channel). This disk-like behavior ensures broad with existing hardware and software stacks. Additionally, optimizing block sizes to match specific workloads can further improve by aligning data transfer units with application requirements, though this requires careful configuration.

Limitations

Block-level storage imposes significant management overhead, as it requires administrators to handle separate file systems for tasks such as formatting, mounting, and recovery, often necessitating specialized expertise. Unlike more abstracted storage types, this direct involvement can increase operational complexity and resource demands, particularly in environments without dedicated storage teams. Scalability presents challenges for block-level storage, as it is tightly coupled to individual servers or hosts, making it difficult to share volumes across distributed systems without implementing complex protocols like or . This architecture limits its suitability for massive workloads, where offers greater horizontal scaling through simpler distribution mechanisms. In cloud environments, block-level storage often incurs higher costs due to provisioned capacity billing models, where users pay for allocated storage regardless of actual usage, potentially leading to over-provisioning and inefficient resource utilization. For instance, services like Amazon EBS charge per gigabyte provisioned per month, contrasting with the usage-based pricing of that aligns costs more closely with consumed data. Raw block exposure in block-level storage can pose security risks, as direct access may allow bypassing file system checks and lead to data damage if not properly managed. Additionally, the limited built-in metadata—typically just unique block identifiers—restricts native support for granular access control, requiring overlying systems to enforce security policies and increasing the potential for misconfiguration vulnerabilities.

History and Evolution

Origins in Early Computing

The origins of block-level storage trace back to the mid-20th century, when computing systems relied primarily on sequential-access media like magnetic tapes for data storage. The introduction of random-access disk drives revolutionized this paradigm by enabling direct access to fixed-size data blocks, allowing for more efficient data management and retrieval. In 1956, IBM unveiled the 305 Random Access Method of Accounting and Control (RAMAC) system, which incorporated the IBM 350 Disk Storage Unit—the world's first commercial hard disk drive. This device featured 50 rotating platters, each 24 inches in diameter, capable of storing up to 5 million characters (approximately 3.75 MB) in fixed blocks of 100 characters each, facilitating random access times of about 600 milliseconds compared to the sequential nature of tapes. By the , advancements in disk technology further solidified the block as the fundamental unit of storage on hard disk drives (HDDs). IBM's 3340 drive, introduced in 1973 and codenamed "" after the rifle model, pioneered a sealed with low-mass read/write heads that landed on lubricated only when spun down, improving reliability and density while maintaining block-based access. This design influenced subsequent HDDs, establishing standardized block sizes typically ranging from 256 to 512 bytes per sector. Concurrently, in 1980, released the ST-506, the first 5.25-inch HDD with 5 MB capacity, which utilized the ST-506 interface—a parallel, asynchronous protocol that became an industry standard for connecting block-oriented disk drives to controllers, supporting up to seven devices per bus and block-level read/write operations. Operating systems of the era integrated these hardware innovations by abstracting disks as block devices, treating them uniformly as files for simplified management. In the , the UNIX operating system, developed at , exemplified this approach by representing disks through special files in the /dev directory, such as /dev/sd0 for block devices, allowing applications to read and write data in fixed blocks via system calls like read() and write(). UNIX s, including precursors to the (UFS), mapped logical file structures onto these physical blocks using inodes—data structures that indexed block addresses—enabling efficient allocation and access without regard to the underlying hardware details. This uniform interface laid the groundwork for portable file system implementations across diverse disk technologies. Standardization efforts in the 1980s formalized block-level interactions between hosts and storage peripherals. The American National Standards Institute (ANSI) approved the Small Computer System Interface (SCSI) standard, X3.131-1986, which defined a bus protocol and command set for block-oriented devices like HDDs, including operations such as READ(6) and WRITE(6) to transfer data in 512-byte blocks. This standard promoted interoperability, allowing multiple vendors' disks to function seamlessly in systems ranging from workstations to servers, and it emphasized error correction and queuing for reliable block access.

Modern Developments

In the late 1990s and early 2000s, the rise of Storage Area Networks (SANs) marked a significant evolution in block-level storage, primarily driven by the adoption of technology. Developed by the (ANSI) in the early 1990s, Fibre Channel provided a high-speed serial interface capable of transferring large data volumes at speeds up to 1 Gbps initially, enabling dedicated storage networks separate from local area networks (LANs). This architecture allowed multiple servers to access shared block storage devices with low latency and high reliability, addressing the limitations of in enterprise environments. By the mid-2000s, Fibre Channel SANs had become the standard for mission-critical applications, supporting topologies like arbitrated loops and switched fabrics to scale connectivity. Complementing this growth, the protocol, pioneered by and in 1998, further democratized block-level access by encapsulating commands over standard TCP/IP networks. This innovation eliminated the need for specialized hardware, allowing organizations to leverage existing Ethernet infrastructure for remote block storage at lower costs, with initial implementations supporting speeds up to 1 Gbps. Ratified as an (IETF) standard in 2004 (RFC 3720), iSCSI facilitated the integration of block storage into IP-based SANs, broadening adoption in small to medium enterprises and paving the way for software-defined storage solutions. The 2010s witnessed a pivotal shift toward cloud-based block storage, exemplified by (AWS) launching Elastic Block Store (EBS) on August 20, 2008, which provided persistent, resizable block-level volumes attachable to EC2 instances for high-performance workloads. EBS volumes offered features like snapshots for backups and elastic resizing, with throughput scaling to gigabytes per second by the mid-2010s. While AWS introduced Multi-AZ deployments for services like RDS in 2010 to enable synchronous replication across AZs for , EBS achieves 99.999% durability through automatic replication within a single AZ, supplemented by asynchronous snapshots and cross-region replication for broader resilience and disaster recovery. This cloud transition enabled dynamic provisioning and pay-as-you-go models, fundamentally altering block storage management in distributed systems. During the 2000s, the adoption of Serial Attached SCSI (SAS) in 2004 and Serial ATA (SATA) in 2003 bridged the transition from HDDs to solid-state drives (SSDs), enabling higher-speed block access and scalability in enterprise environments. The advent of SSDs and the Non-Volatile Memory Express (NVMe) protocol in 2011 revolutionized block storage performance by optimizing the interface for flash-based media, reducing latency to microseconds and increasing IOPS by orders of magnitude compared to traditional hard disk drives (HDDs). The NVMe 1.0 specification, developed by a consortium including Intel and the National Storage Industry Consortium, introduced up to 64,000 queues with 64,000 commands each, leveraging PCIe lanes for parallel processing and eliminating SCSI overhead. This shift enabled SSDs to deliver sustained throughputs exceeding 3 GB/s in enterprise arrays, transforming block storage for latency-sensitive applications like databases and virtualization. Building on this, NVMe over Fabrics (NVMe-oF), with development starting in 2014 under the NVM Express organization, extended NVMe's efficiency to networked environments over Ethernet, Fibre Channel, and InfiniBand, achieving near-local performance with sub-millisecond latencies in disaggregated setups. By 2024 and into 2025, block-level storage has increasingly integrated with AI workloads, emphasizing ultra-low latency solutions like NVMe-oF to handle the massive, real-time data demands of training and inference. Hyperscale data centers, operated by providers such as AWS and , have adopted disaggregated storage architectures, where block volumes are pooled and dynamically allocated across compute nodes via protocols like NVMe-oF over RDMA, reducing costs and improving scalability for AI clusters processing petabytes of data. This trend, driven by AI's , has projected the global block storage market to reach USD 77.26 billion by 2032, with innovations in zoned namespace (ZNS) SSDs further optimizing endurance and throughput for hyperscale environments.

References

  1. https://www.ibm.com/think/topics/block-storage
  2. https://www.netapp.com/data-storage/what-is-block-storage/
  3. https://www.cloudflare.com/learning/cloud/what-is-block-storage/
  4. https://www.redhat.com/en/topics/data-storage/file-block-object-storage
  5. https://www.hpe.com/us/en/what-is/block-storage.html
  6. https://www.oracle.com/cloud/storage/block-volumes/what-is-block-storage/
  7. https://aws.amazon.com/what-is/block-storage/
  8. https://www.redhat.com/en/topics/data-storage/file-block-object-storage/
  9. https://aws.amazon.com/compare/the-difference-between-block-file-object-storage/
  10. https://learn.microsoft.com/en-us/troubleshoot/windows-server/backup-and-storage/support-for-hard-disks-exceeding-2-tb
  11. https://docs.redhat.com/en/documentation/red_hat_enterprise_linux/8/html/managing_file_systems/overview-of-available-file-systems_managing-file-systems
  12. https://learn.microsoft.com/en-us/azure/virtual-machines/premium-storage-performance
  13. https://learn.microsoft.com/en-us/azure/azure-sql/virtual-machines/windows/performance-guidelines-best-practices-storage?view=azuresql
  14. https://www.ibm.com/think/topics/object-vs-file-vs-block-storage
  15. https://www.netapp.com/learn/cvo-blg-what-is-block-storage-pros-cons-and-comparisons/
  16. https://www.cloudflare.com/learning/cloud/object-storage-vs-block-storage/
  17. https://www.oracle.com/cloud/storage/block-volumes/what-is-block-storage/vs-object-storage/
  18. https://cloudian.com/guides/object-storage/object-storage-vs-block-storage/
  19. https://www.purestorage.com/knowledge/what-is-block-storage.html
  20. https://chemnitzer.linux-tage.de/2021/media/programm/folien/165.pdf
  21. https://www.redhat.com/en/blog/linux-block-devices-hints-debugging-and-new-developments
  22. https://www.baeldung.com/linux/dev-sda
  23. https://www.ietf.org/rfc/rfc3720.txt
  24. https://fibrechannel.org/wp-content/uploads/2019/04/Fibre-Channel-Protocol-Analysis-201-Final.pdf
  25. https://nvmexpress.org/wp-content/uploads/NVM-Express-Base-Specification-Revision-2.3-2025.08.01-Ratified.pdf
  26. https://nvmexpress.org/wp-content/uploads/NVM-Express-NVMe-over-PCIe-Transport-Specification-Revision-1.3-2025.08.01-Ratified.pdf
  27. https://www.techtarget.com/searchstorage/definition/direct-attached-storage
  28. https://www.techtarget.com/searchstorage/definition/LUN-masking
  29. https://nvmexpress.org/wp-content/uploads/NVM-Express-NVMe-over-RDMA-Transport-Specification-Revision-1.2-2025.08.01-Ratified.pdf
  30. https://nvmexpress.org/wp-content/uploads/NVMe_Over_Fabrics.pdf
  31. https://docs.redhat.com/en/documentation/red_hat_enterprise_linux/8/html-single/configuring_and_managing_logical_volumes/index
  32. https://docs.redhat.com/en/documentation/red_hat_enterprise_linux/5/html/deployment_guide/ch-lvm
  33. https://docs.redhat.com/en/documentation/red_hat_enterprise_linux/9/html/configuring_and_managing_logical_volumes/basic-logical-volume-management_configuring-and-managing-logical-volumes
  34. https://docs.redhat.com/en/documentation/red_hat_enterprise_linux/8/html/configuring_and_managing_logical_volumes/advanced-logical-volume-management_configuring-and-managing-logical-volumes
  35. https://docs.oracle.com/en-us/iaas/private-cloud-appliance/cmn/block/block-volume-storage.htm
  36. https://docs.kernel.org/admin-guide/device-mapper/thin-provisioning.html
  37. https://docs.redhat.com/en/documentation/red_hat_enterprise_linux/8/html/managing_storage_devices/managing-raid_managing-storage-devices
  38. https://docs.redhat.com/en/documentation/red_hat_enterprise_linux/7/html/storage_administration_guide/raid-subsys
  39. https://nordic-backup.com/blog/block-level-backup-and-restore/
  40. https://www.commvault.com/explore/bare-metal-recovery
  41. http://wiki.r1soft.com/display/TP/Block%2BBased%2BBackup%2BTechnology
  42. https://www.netapp.com/oracle/
  43. https://dl.dell.com/manuals/all-products/esuprt_software/esuprt_it_ops_datcentr_mgmt/s-solution-resources_white-papers4_en-us.pdf
  44. https://www.vmware.com/content/dam/digitalmarketing/vmware/en/pdf/solutions/vmware-oracle-databases-on-vmware-best-practices-guide.pdf
  45. https://www.netapp.com/data-storage/san-storage-area-network/
  46. https://www.netapp.com/fas/
  47. https://docs.redhat.com/en/documentation/red_hat_enterprise_linux/8/html/security_hardening/encrypting-block-devices-using-luks_security-hardening
  48. https://docs.aws.amazon.com/ebs/latest/userguide/what-is-ebs.html
  49. https://cloud.google.com/persistent-disk
  50. https://learn.microsoft.com/en-us/azure/virtual-machines/managed-disks-overview
  51. https://docs.vmware.com/en/VMware-vSphere/8.0/com.vmware.vsphere.storage.doc/GUID-5EE84941-366D-4D37-8B7B-767D08928888.html
  52. https://docs.cloud.google.com/compute/docs/disks/regional-persistent-disk
  53. https://learn.microsoft.com/en-us/azure/virtual-machines/disks-redundancy
  54. https://docs.aws.amazon.com/ebs/latest/userguide/ebs-snapshots.html
  55. https://cloud.google.com/compute/docs/disks/create-snapshots
  56. https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/InstanceStorage.html
  57. https://kubernetes.io/docs/concepts/storage/persistent-volumes/
  58. https://kubernetes.io/docs/concepts/storage/dynamic-provisioning/
  59. https://docs.netapp.com/us-en/ontap/concepts/thin-provisioning-concept.html
  60. https://www.ibm.com/docs/en/storage-scale/5.2.2?topic=devices-storage-scale-thin-provisioned
  61. https://www.netapp.com/media/19746-ds-2477.pdf
  62. https://docs.netapp.com/us-en/ontap/concepts/snapshot-copies-concept.html
  63. https://www.digitalocean.com/resources/articles/block-storage-vs-object-storage
  64. https://aws.amazon.com/ebs/pricing/
  65. https://www.fsl.cs.sunysb.edu/docs/integrity-storagess05/integrity.html
  66. https://www.ibm.com/history/ramac
  67. https://www.historyofinformation.com/detail.php?entryid=952
  68. https://www.computerhistory.org/storageengine/winchester-pioneers-key-hdd-technology/
  69. https://www.computerhistory.org/storageengine/seagate-5-25-inch-hdd-becomes-pc-standard/
  70. https://dl.acm.org/doi/10.1145/361011.361061
  71. https://blog.ansi.org/ansi/incits-131-1994-2013-computer-systems-interface/
  72. https://www2.rivier.edu/faculty/vriabov/Riabov_SAN_Encyclopedia.pdf
  73. https://www.sciencedirect.com/topics/computer-science/storage-area-network
  74. https://www.techtarget.com/searchstorage/definition/iSCSI
  75. https://www.allthingsdistributed.com/2024/08/continuous-reinvention-a-brief-history-of-block-storage-at-aws.html
  76. https://aws.amazon.com/about-aws/whats-new/2010/05/18/announcing-multi-az-deployments-for-amazon-rds/
  77. https://nvmexpress.org/wp-content/uploads/NVMe_Overview.pdf
  78. https://nvmexpress.org/ssd-drives-promise/
  79. https://blocksandfiles.com/2025/10/27/ai-driving-data-centre-and-storage-transformation/
  80. https://www.gminsights.com/blogs/data-center-outlook
  81. https://www.researchandmarkets.com/report/block-storage
Add your contribution
Related Hubs
User Avatar
No comments yet.