How to Configure Software RAID in Linux Using mdadm (Step-by-Step Guide)

In Linux environments, managing disk storage efficiently is a key responsibility of system administrators. Software RAID in Linux managed using mdadm, allows you to combine multiple disks to improve performance, ensure redundancy or achieve both—without requiring dedicated hardware.

In this complete guide, you’ll learn how to configure Software RAID in Linux using mdadm step by step, along with real commands, examples and best practices.

Introduction to Software RAID in Linux

What is Software RAID in Linux?

Software RAID (Redundant Array of Independent Disks) is a method of combining multiple physical disks into a single logical unit using the operating system. Linux uses tools like mdadm to manage RAID arrays, Instead of relying on a hardware RAID controller.

To understand Linux storage management and disk redundancy in depth, read our guide What is LVM in Linux? Easily Manage Disks with Logical Volume Manager . It explains how LVM works with Linux storage and how it differs from Software RAID.

Why Use Software RAID?

Benefit	Description
Performance	Faster read/write speeds with striping (RAID 0, RAID 10)
Redundancy	Protects against disk failure (RAID 1, RAID 5, RAID 10)
Cost	No extra hardware required (uses system resources)
Flexibility	Easy to create, modify, and manage using mdadm
Scalability	Add or expand disks as storage needs grow
High Availability	System continues running even if a disk fails
Easy Recovery	Supports rebuild and recovery of failed disks
No Vendor Lock-In	Works across different hardware systems
Integration	Works seamlessly with LVM, ext4, XFS, and Linux tools
Transparency	Fully managed at OS level (no hidden hardware logic)
Portability	RAID arrays can be moved between Linux systems
Monitoring	Built-in tools for health checks and alerts

Common RAID Levels

Real-World Use Cases

Use Case	Recommended RAID	Why It’s Used
Web Servers	RAID 1	Ensures high availability and uptime with disk mirroring; continues running if one disk fails
Database Servers	RAID 10	Provides high read/write performance with redundancy; ideal for heavy I/O workloads
Backup & Storage Servers	RAID 5	Balances storage efficiency and fault tolerance; supports large data volumes
Home Labs	RAID 1	Simple and reliable setup for protecting personal data and lab environments
Virtualization Hosts	RAID 10	Handles multiple virtual machines with high performance and low latency
Media & File Servers	RAID 5 / RAID 6	Maximizes storage capacity while providing protection against disk failure
Enterprise Applications	RAID 10	Ensures performance, reliability, and faster recovery in production systems
Log Servers	RAID 1	Protects critical logs and ensures data integrity
Archival Systems	RAID 6	Allows failure of two disks; suitable for long-term data storage

Understanding mdadm in Linux

What is mdadm?

mdadm (Multiple Device Admin) is a Linux utility used to create, manage and monitor software RAID arrays.

Key Features

·       Create and manage RAID arrays

·       Monitor RAID health

·       Rebuild failed disks

·       Supports multiple RAID levels

Check if mdadm is installed

mdadm --version

If not installed:

For Ubuntu/Debian:

sudo apt update

sudo apt install mdadm -y

For RHEL/CentOS:

sudo yum install mdadm -y

Prerequisites for Configuring Software RAID

·       At least 2 or more disks (e.g., /dev/sdb, /dev/sdc)

·       Root or sudo privileges

·       Clean/unmounted disks

Identify Available Disks

lsblk

Important Notes

·       RAID setup will erase all data on selected disks

·       Always take a backup before proceeding

Before configuring Software RAID, it is also important to understand Linux disk and filesystem structure. Read our detailed guide Linux Directory Structure and File System Guide.

Step-by-Step: Configure Software RAID using mdadm

Step 1: Create RAID Array

Create RAID 1 (Mirroring)

sudo mdadm --create --verbose /dev/md0 --level=1 --raid-devices=2 /dev/sdb /dev/sdc

Explanation:

•         /dev/md0                  Raid device name

•         --level=1                     RAID 1

•         --raid-devices=2       Number of disks

Step 2: Verify RAID Array

After creating a RAID array, you should always verify that it is working correctly. There are two commonly used commands:

cat /proc/mdstat

This command displays the current status of all RAID arrays in the system.

What it shows:

·       Active RAID devices (e.g., /dev/md0)

·       RAID level (RAID1, RAID5, etc.)

·       Member disks (e.g., sdb, sdc)

·       Sync/rebuild progress

·       Disk health status

Explanation:

·       raid1 - RAID level

·       sdb[0] sdc[1] - disks in array

·       [2/2] - total disks / active disks

·       [UU] - both disks are healthy

·       U = Up (working)

·       _ = Failed/missing disk

This is the fastest way to monitor RAID health.

OR

sudo mdadm --detail /dev/md0

This command provides in-depth information about a specific RAID device.

What it shows:

·       RAID level and size

·       UUID of the array

·       Number of devices

·       Status of each disk

·       Failed or spare disks

·       Rebuild status (if any)

Explanation:

·       State: clean - RAID is healthy

·       Active sync - disks are properly synced

·       Displays precise disk functions and state

It can be helpful in troubleshooting and in-depth analysis.

Tip: Use real-time monitoring with

Watch cat /proc/mdstat

This continuously updates RAID status, useful during rebuilds.

Step 3: Create a Filesystem on RAID Array

This command creates an EXT4 filesystem on the RAID device /dev/md0, allowing it to be used like a normal disk for storing data.

sudo mkfs.ext4 /dev/md0

What This Command Does

·       mkfs.ext4 - Creates a filesystem using the EXT4 format

·       /dev/md0 - RAID array device you created using mdadm

Once this command is run the RAID array is now ready to be mounted and files can be stored.

Why This Step is Important

Without a filesystem:

·       The RAID device exists but you cannot store data on it

·       Linux requires a filesystem like EXT4, XFS to organize data

This step transforms a RAID array in a fully functional storage volume.

Important Notes

·       This command deletes all the data in /dev/md0

·       Make sure the RAID array is correctly configured before running it

You can use other filesystems if needed:

·       XFS - mkfs.xfs

·       EXT3 - mkfs.ext3

Pro Tip:

For large storage systems or databases, consider using:

·       XFS for better performance on large files

·       Custom block sizes depending on workload

Step 4: Create a Mount Point for the RAID Array

This command creates a directory named /mnt/raid1, which will be used as a mount point for the RAID array.

sudo mkdir /mnt/raid1

What This Command Does

·       mkdir - Creates a new directory

·       /mnt/raid1 - Location where the RAID device will be attached

In Linux, storage devices must be mounted to a directory to become accessible.

Why This Step is Important

The RAID device (/dev/md0) cannot be accessed directly

You need a mount point (a folder) to:

·       Read and write files

·       Store data

·       Access the RAID volume like a normal directory

This directory serves as a entry point to your RAID storage.

Why /mnt/raid1?

·       /mnt is a standard directory used for temporary mount points

·       RAID1 is just a descriptive name (you can change it)

Important Notes

·       The directory must be exist before mounting

·       If it doesn’t exist, the mount command will fail

·       You can name it anything meaningful (e.g., /storage, /backup, /raid)

Step 5: Mount RAID Array

This command attaches RAID device to the mount point, making it accessible for reading and writing data.

sudo mount /dev/md0 /mnt/raid1

Verify:

You should see /dev/md0 listed with its mounted location.

df -h

To improve Linux system administration skills, explore our tutorial on Linux Process Management Complete Guide, where you will learn how Linux manages processes and system resources efficiently.

Step 6: Make the Mount Persistent

By default, mounts are temporary and will be lost after a reboot. To make it permanent:

6.1 Get the UUID

sudo blkid /dev/md0

6.2 Edit the fstab file and Add the Following Entry

sudo nano /etc/fstab

UUID=xxxx-xxxx  /mnt/raid1  ext4  defaults  0  0

Why this step matters:

This ensures the RAID array is automatically mounted every time the system boots.

Pro Tip:

sudo mount -a

This is a directory used as an entry point of your RAID storage. Assuming that no errors are displayed, you have configured it correctly.

Step 7: Save RAID Configuration

This command will s the current RAID configuration so the system can automatically reassemble the RAID array after reboot.

sudo mdadm --detail --scan | sudo tee -a /etc/mdadm/mdadm.conf

What This Command Does

mdadm --detail --scan

Scans all active RAID arrays and outputs their configuration details (including UUID and devices)

| (pipe)   passes the output of the first command to the next command

tee -a /etc/mdadm/mdadm.conf Appends (-a) the RAID configuration to the mdadm config file

Why This Step is Important

Without saving this configuration:

·         The RAID array might not reconfigure itself on reboot

·         You might need to manually reassemble it each time

This will make your RAID configuration persistent and reliable.

Important Notes

·         Avoid running this command multiple times without checking the file

·         It may create duplicate entries

Step 8: Apply Changes

After saving the configuration, update the initramfs:

sudo update-initramfs -u

    This ensures the RAID configuration is loaded during system boot.

After this step:

•   RAID configuration is saved

•   System can auto-detect RAID arrays

•  No manual intervention needed after reboot

Configure Different RAID Levels

RAID 0 (Performance)

This command creates a RAID 0 (striping) array using two disks /dev/sdb and /dev/sdc.

sudo mdadm --create /dev/md0 --level=0 --raid-devices=2 /dev/sdb /dev/sdc

Command Explanation

·         mdadm --create - Creates a new RAID array

·         /dev/md0 - Name of the RAID device

·         --level=0 - Specifies the RAID 0 (striping)

·         --raid-devices=2 - Number of disks used

·         /dev/sdb, /dev/sdc - Physical disks included in the array

RAID 0 splits (stripes) data across multiple disks:

·         Data is divided into blocks

·         Blocks are written across both disks simultaneously

·         This improves read/write performance

Example:

File A - split into parts, written to both disks at the same time

Benefits of RAID 0

·         High performance (fast read/write speeds)

·         Full disk capacity is usable

Ideal for:

·         Temporary data

·         Caching

·         Non-critical workloads

Important Warning:

RAID 0 provides no redundancy:

•         If one disk fails - all data is lost

•         No recovery possible without backups

Use RAID 0 when performance is more important than data safety.

When to Use RAID 0

•         Testing environments

•         High-speed processing tasks

Pro Tip:

You can optimize performance using chunk size:

sudo mdadm --create /dev/md0 --level=0 --raid-devices=2 --chunk=256 /dev/sdb /dev/sdc

Larger chunk sizes improve performance for large files.

RAID 5 (Parity)

This command creates a RAID 5 array using three disks: /dev/sdb, /dev/sdc, and /dev/sdd.

sudo mdadm --create /dev/md2 --level=5 --raid-devices=3 /dev/sdb /dev/sdc /dev/sdd

What This Command Does

·         mdadm --create - Creates a new RAID array

·         /dev/md2 - Name of the RAID device

·         --level=5 - Specifies RAID 5 (striping with parity)

·         --raid-devices=3 - Minimum number of disks required for RAID 5

·         /dev/sdb, /dev/sdc, /dev/sdd - Disks included in the array

How RAID 5 Works

RAID 5 combines striping + parity:

•         Data is split across all disks like RAID 0

•         Parity information is distributed across all disks

•         Parity allows recovery if one disk fails

Example:

•         Data blocks stored across disks

•         Parity block rotates between disks

•         If one disk fails - data is rebuilt using parity

Benefits of RAID 5

•         Fault tolerance (can survive one disk failure)

•         Better storage efficiency than RAID 1

•         Balanced performance and redundancy

Important Considerations:

•         Minimum 3 disks required

•         Written performance is slow than RAID 0 due to parity calculations

•         Rebuild time can be slow on large disks

When to Use RAID 5

•         Backup storage systems

•         File servers

•         Environments need a balance between capacity and protection

Pro Tip:

You can define chunk size for better performance:

sudo mdadm --create /dev/md2 --level=5 --raid-devices=3 --chunk=256 /dev/sdb /dev/sdc /dev/sdd

Larger chunk sizes are better for large sequential data.

Managing Software RAID Arrays

1.  Check RAID Status

cat /proc/mdstat

2. Add a New Disk to an Existing RAID Array

sudo mdadm /dev/md0 --add /dev/sdd

Command Explanation

•         mdadm /dev/md0 - Targets the existing RAID array

•         --add - Adds a new disk to the array

•         /dev/sdd - The disk being added

When This Command is used

This command is typically used in scenarios such as:

•         Replacing a failed disk

•         Adding a spare disk for redundancy

•         Expanding certain RAID configurations

Common Use Cases (Disk Replacement)

If a disk fails in RAID (e.g., RAID 1 or RAID 5):

•         Remove the failed disk

•         Insert a new disk

What Happens After Adding

•         The RAID array begins rebuild/resync automatically

•         Data is copied to the new disk

•         System remains usable during rebuild (but performance may drop)

Important Notes

The new disk should be:

·         Equal or larger in size than existing disks

·         Unmounted and free of data

RAID level matters:

•         RAID 1 / RAID 5 - supports rebuild

•         RAID 0 - cannot recover or rebuild

Pro Tip (Best Practice)

Before adding a new disk, it’s recommended to:

sudo mdadm --zero-superblock /dev/sdd

This removes any old RAID metadata and prevents conflicts.

Remove a Disk

These commands are used to safely remove a faulty or unwanted disk from a RAID array.

1. Mark a Disk as Failed

sudo mdadm /dev/md0 --fail /dev/sdd

•         Flags /dev/sdb as failed in the RAID array

•         Stops using the disk for read/write operations

•         Prepares it for safe removal

2. Remove the Disk from the Array

sudo mdadm /dev/md0 --remove /dev/sdb

•         Removes the failed disk from the RAID configuration

•         Updates the array metadata

•         Frees the device for replacement or reuse

Why this is Important

You should never directly remove a disk without lebel it as failed first.

Proper sequence ensures:

•         Data integrity

•         Stable RAID operation

•         Correct rebuild behavior

When to Use These Commands

•         A disk shows error or become unresponsive

•         You have changed a failed disk

•         You want to remove a disk from RAID safely

What Happens Next

After removing the disk:

•        RAID enters a degraded state (if redundant RAID like RAID 1 or RAID 5)

•        You should add a replacement disk as soon as possible

Monitor RAID

watch cat /proc/mdstat

RAID Troubleshooting and Recovery

Replace Failed Disk

sudo mdadm /dev/md0 --add /dev/sdd

Rebuild RAID:

Rebuild starts automatically after adding a new disk.

Check progress:

cat /proc/mdstat

Examine RAID Issues

dmesg | grep md

How to Remove RAID

Removing a RAID array must be done carefully to avoid data loss and leftover metadata issues. Follow these steps to safely remove a RAID array using mdadm

Before you start

•         Take backup of your data because RAID removal deletes the records

•         Identify RAID device e.g. /dev/md0

•         Make sure no critical service is using it

Step 1 Check Existing RAID Array

This command displays active RAID arrays and their status.

sudo cat /proc/mdstat

Step 2 Unmount RAID Filesystem

This detaches the filesystem so it can be safely removed.

sudo umount /dev/md0

If it is mounted on directory then

sudo umount /mnt/raid1

Step 3 Stop the RAID Array

This deactivates the RAID device.

sudo mdadm --stop /dev/md0

Step 4 Remove the RAID Device

This command removes the RAID array from the system.

sudo mdadm --remove /dev/md0

Step 5 Clear a RAID Metadata from Disks

This is very important step and it prevents auto reassembly.

sudo mdadm --zero-superblock /dev/sdb

sudo mdadm --zero-superblock /dev/sdd

Note: run for all disks.

Step 6 Verify RAID Removed

No RAID arrays should appear in the output.

sudo cat /proc/mdstat

Step 7 Remove RAID Entry from Config

Edit config file:

sudo nano /etc/mdadm/mdadm.conf

Remove lines related to /dev/md0.

Update initramfs

sudo update-initramfs -u

Step 8 Remove Mount Entry if Added

sudo nano /etc/fstab

Delete UUID=XXXX /mnt/raid1 ext4 defaults 0 0

Quick Command Summary

Software RAID vs Hardware RAID

Feature	Software RAID	Hardware RAID
Cost	Free (no extra hardware)	Expensive (requires RAID controller)
Performance	Good (depends on CPU)	High (dedicated controller + cache)
Flexibility	Very flexible (managed via OS tools like mdadm)	Limited (depends on controller features)
Ease of Setup	Easy and transparent	Requires controller configuration
Portability	High (can move disks between systems)	Low (tied to specific controller)
CPU Usage	Uses system CPU	Offloads processing to controller
Recovery	Easier and more transparent	Can be complex if controller fails
Scalability	Flexible but OS-dependent	Limited by hardware capabilities

Best Practices for Software RAID

Best Practice	Description
Choose the Right RAID Level	Match RAID to workload (RAID 1 for safety, RAID 5 for balance, RAID 10 for performance)
Always Keep Backups	RAID is not a backup; always maintain separate backups
Use Identical Disks	Same size and speed disks ensure optimal performance and no wasted space
Monitor RAID Regularly	Use cat /proc/mdstat and mdadm --detail to track health
Replace Failed Disks Quickly	Avoid running in degraded mode to reduce risk of data loss
Enable Alerts	Configure email alerts in mdadm for instant failure notifications
Save RAID Configuration	Persist config using mdadm --detail --scan to avoid reboot issues
Use Reliable Power (UPS)	Prevent data corruption during unexpected power failures

FAQs about Software RAID in Linux

Q1.What is Software RAID in Linux?

Software RAID is a method of combining multiple physical disks into a single logical unit using the operating system (typically with mdadm) to improve performance, redundancy or both in Linux.

Q2. Is Software RAID reliable in Linux?

Yes, Software RAID is reliable when configured and monitored it properly. Linux’s mdadm tool is widely used in production environments and supports fault tolerance, disk recovery and monitoring features.

Q3. Which RAID level is best for Linux servers?

It depends on your use case:

RAID 1 - Best for data safety

RAID 5 - Good balance of performance and redundancy

RAID 10 - Best for high-performance production systems

Q4. What is the effect of a disk failure in RAID?

When a disk fails:

The RAID array becomes degraded

Data remains accessible (except RAID 0)

Replace a failed disk and rebuild an array

Q5. Can I expand a RAID array in Linux?

Yes, you can expand a RAID array by adding more disks using mdadm but the process depends on the RAID level and requires careful planning.

📌 Related Articles

• What is LVM in Linux? – Easily manage disks and storage using Logical Volume Manager in Linux
• Linux Directory Structure Guide – Understand Linux filesystem hierarchy from beginner to professional level
• Linux Process Management Guide – Learn Linux process management, monitoring, and troubleshooting
• Linux Boot Process Explained – Learn how Linux initializes hardware and starts system services step by step
• Linux Tutorials & Guides – Explore Linux administration, storage, networking, and command-line tutorials

Conclusion

Linux software RAID using mdadm provides an affordable and efficient method of managing storage without relying on dedicated hardware. RAID 0 improves performance, RAID 1 ensures data protection, and RAID 5 or RAID 10 offer a balance between efficiency and redundancy.

In this guide, you learned how to create RAID arrays, manage and monitor disks, handle failures, and safely remove RAID configurations when needed.

However, it’s important to remember that RAID is not a backup solution. Always combine RAID with a proper backup strategy to protect critical data.

With these skills, you are now ready to confidently deploy and manage software RAID in real-world Linux environments.

SeekLinux Team
Linux Engineers | DevOps | Security Enthusiasts

SeekLinux Team shares practical Linux tutorials, SSL/TLS certificate guides, commands and DevOps solutions. Our goal is to simplify system administration and help you master real-world server and security tasks.

Learn more about us →