Understanding RAID Levels: Definitions, Pros, Cons, and Practical Linux Commands

RAID Definition

RAID (Redundant Array of Independent Disks) combines multiple physical disks into a logical unit to improve read/write performance and data safety.

Based on different combination methods, RAID levels include:

Level   Description
RAID 0  Data striping, no parity
RAID 1  Data mirroring, no parity
RAID 3  Striping with dedicated parity disk
RAID 5  Striping with distributed parity
RAID 6  Striping with double distributed parity

Combining two RAID methods can create new levels:

Level   Description
RAID 0+1  Stripe then mirror (both striping and mirroring)
RAID 10   Mirror then stripe (similar to 0+1 but order reversed)
RAID 50   Stripe then RAID 5 (improves RAID 5 performance)

RAID 0

Definition:

RAID 0 is a striped disk array without fault tolerance; data is evenly distributed across disks.

Advantages:

Very high read/write efficiency.

Fast because no parity calculation consumes CPU.

Simple deployment.

Disadvantages:

No redundancy; usually combined with other RAID levels.

Not suitable for critical data.

Minimum number of disks: 2

RAID 1

Definition:

RAID 1 (Mirror) writes identical data to a primary disk and a mirror disk.

Advantages:

High data safety and availability.

100% data redundancy.

Simple design and use.

Low CPU usage because no parity calculation.

Disadvantages:

Effective storage capacity is only half.

Does not improve write performance compared to a single disk.

RAID 5

Definition:

RAID 5 distributes both data and parity information across all disks, providing fault tolerance without a dedicated parity disk.

Advantages:

High read speed, moderate write speed.

Provides a degree of data safety.

Disadvantages:

If a single disk fails, read/write performance of the remaining disks drops sharply.

Minimum number of disks: 3

Common RAID Comparison

RAID Level | Alias          | Fault Tolerance | Redundancy Type | Hot Spare | Read Performance | Random Write | Sequential Write | Minimum Disks | Usable Capacity | Typical Use Cases
-----------|----------------|----------------|-----------------|-----------|-------------------|--------------|------------------|----------------|------------------|-------------------
RAID 0    | Striping       | None           | None            | No        | High              | High         | High             | 2              | N * disk size    | Fast read/write, low safety (e.g., graphics workstations)
RAID 1    | Mirroring      | Yes            | Copy            | Yes       | Low               | Low          | Low              | 2              | (N/2) * disk size| High safety, random writes (e.g., servers, DB storage)
RAID 3    | Dedicated parity| Yes           | Parity          | Yes       | High              | Lowest       | Low              | 3              | (N‑1) * disk size| Continuous transfer, high safety (e.g., video editing)
RAID 5    | Distributed parity| Yes        | Parity          | Yes       | High              | Low          | Low              | 3              | (N‑1) * disk size| High safety, random transfers (e.g., finance, DB)
RAID 10   | Mirrored stripe| Yes            | Copy            | Yes       | Medium            | Medium       | Medium           | 4              | (N/2) * disk size| Large data, high safety (e.g., banking)
RAID 0+1  | Stripe mirror  | Yes            | Copy            | Yes       | High              | Medium       | Medium           | 4              | (N/2) * disk size| High performance & safety (e.g., video servers)

Common RAID Selection

RAID 5 is a compromise between RAID 0 and RAID 1, offering data safety lower than RAID 1 but higher storage efficiency.

RAID 5 provides read speeds comparable to RAID 0, with a slight write penalty due to parity; its storage utilization is higher than RAID 1, reducing cost.

Hot Spare

Definition: When a disk in a redundant RAID group fails, a designated spare disk automatically replaces the failed one without interrupting the array.

Global spare: shared by all redundant RAID groups.

Dedicated spare: assigned to a specific RAID group.

Usable capacity reduces from (N‑1)×disk to (N‑2)×disk (e.g., RAID 5).

Hot Swap

Definition: Replace a failed disk with a healthy one while the system continues to run.

The key is protecting electronic components during hot‑swap operations.

Experiment Goal

Create a RAID 5 array on a server using four disks.

Experiment Commands

lsblk</code>
<code>mdadm -Cv /dev/md0 -n 4 -l 10 /dev/sdc /dev/sdd /dev/sde /dev/sdf</code>
<code># Set up RAID instance</code>
<code>mdadm -Q /dev/md0</code>
<code># Verify md device</code>
<code>mdadm -D /dev/md0</code>
<code>mkfs.ext4 /dev/md0</code>
<code># Create filesystem</code>
<code>mkdir /Raid</code>
<code>mount /dev/md0 /Raid/</code>
<code># Mount</code>
<code>df -h

Use /dev/sd{b,c,d,e} to create a RAID5 array.

mdadm -Cv /dev/md0 -n 3 -l 5 -a yes -x 1 /dev/sd{b,c,d,e}</code>
<code># -C: create /dev/md0</code>
<code># -v: verbose</code>
<code># -n: number of disks</code>
<code># -l: RAID level</code>
<code># -a: auto‑create device file</code>
<code># -x: number of hot‑spare disks</code>
<code># Note: n + x equals actual physical disks used</code>
<code>mdadm -D /dev/md0</code>
<code># Show RAID info

Simulate disk failure in the RAID.

mdadm /dev/md0 -f /dev/sdb</code>
<code># Simulate failure of /dev/sdb in /dev/md0</code>
<code># Observe RAID status

Format and mount.

mkfs.[desired_fs] /dev/md0</code>
<code># Format the RAID array</code>
<code>mount /dev/md0 /mnt/md0</code>
<code># Mount to /mnt/md0</code>
<code>df -Th</code>
<code># Check mount status</code>
<code># Add to /etc/fstab for auto‑mount; use mount -a to verify

Delete the RAID array (ensure data backup first).

umount /mnt/md0 /dev/md0</code>
<code># Unmount first</code>
<code>mdadm -s /dev/md0</code>
<code>mdadm -r /dev/md0</code>
<code># -s: stop RAID
# -r: remove RAID array
# Data remains on disks

Common Linux Disk Commands

df – display disk usage (e.g., df -h).

du – show file or directory disk usage.

fdisk – partitioning tool for creating, deleting, modifying partitions.

mkfs – create a filesystem (e.g., mkfs ext4 /dev/sda1).

mount – mount a filesystem to a mount point.

umount – unmount a filesystem.

lsblk – list block devices in a tree view.

blkid – display UUID and filesystem type of block devices.

badblocks – check and mark bad blocks.

smartctl – read SMART data to assess disk health.