LVM Basics: Flexible Storage Management

1. Why LVM? The Problem with Static Partitions

Traditionally, a hard drive is partitioned into fixed-size segments (e.g., /dev/sda1, /dev/sda2). If your /var/log partition fills up, you're in trouble. You can't easily give it space from another partition. This inflexibility is a major challenge in dynamic server environments.

LVM solves this by adding a layer of abstraction between your physical disks and your filesystems. Let's see a practical demonstration of the problem and the LVM solution.

2. The Architecture of LVM

The magic of LVM comes from its three core components, which form a hierarchy:

1. Physical Volumes (PVs): These are the raw building blocks. A PV can be a whole disk (like /dev/sdb), a partition (like /dev/sdb1), or any block device. You initialize a device as a PV to tell LVM it's available for use.
2. Volume Groups (VGs): A VG is a pool of storage created by grouping one or more PVs. Think of it as one giant, virtual disk. You can add more PVs to a VG at any time to increase the size of the pool.
3. Logical Volumes (LVs): An LV is what your operating system sees and uses. You carve LVs out of the space available in a VG. These LVs behave like regular partitions—you format them with a filesystem (like ext4 or xfs) and mount them. The key difference is that they can be easily resized as long as there is free space in the parent Volume Group.

This diagram from the Red Hat documentation clearly illustrates the relationship:

To get a more dynamic explanation of this structure, let's turn back to the video.

3. Creating an LVM Setup: A Step-by-Step Guide

Let's walk through the process of taking new, raw disks and turning them into a usable, flexible filesystem with LVM. We'll use a scenario-based approach, which is common when setting up a new server. For this, we'll follow a tutorial that uses Red Hat-based tools and the XFS filesystem, which are common in enterprise environments.

The video below provides a very clear, command-line-driven walkthrough. I recommend you open a terminal and follow along on a practice VM if you have one.

Here is a summary of the key commands from that process:

For an official reference on these commands, the Red Hat documentation is an invaluable resource.

4. Resizing LVM Volumes: The Core Advantage

Now for the main event. Your application's data volume, /dev/my_vg/my_lv, is 85% full. You've attached a new disk to the VM. Let's extend the volume.

The process involves working up the LVM hierarchy and then back down to the filesystem:

1. Initialize the new disk as a Physical Volume (pvcreate).
2. Extend the Volume Group to include the new PV (vgextend).
3. Extend the Logical Volume to use the new space (lvextend).
4. Resize the filesystem to recognize and use the larger LV size (resize2fs or xfs_growfs).

The video from beanologi demonstrates this flow perfectly.

The -r / --resizefs Shortcut

Many LVM commands have a powerful shortcut option, -r or --resizefs, that performs the final filesystem resize for you. This combines steps 3 and 4 into a single, atomic operation.

For an ext4 filesystem:
# lvextend -L +5G -r /dev/my_vg/my_lv

For an xfs filesystem, you'd use xfs_growfs as shown in the video, because XFS resizing capabilities are handled by its own toolset which lvextend -r may not always correctly invoke depending on the system version. However, modern LVM versions often handle this correctly. The explicit two-step process (lvextend then xfs_growfs) is always safe.

The next video segment shows this shortcut and also discusses shrinking volumes.

5. Management Task: Safely Removing a Disk

Another common real-world scenario is decommissioning a disk. You can't simply pull a physical disk that is part of an active volume group. LVM provides a safe, non-disruptive way to do this.

The process is:

1. pvmove /dev/sdd1: This command migrates all data off the PV you want to remove (/dev/sdd1) and onto other PVs within the same VG. This can be done while the filesystem is online.
2. vgreduce my_vg /dev/sdd1: Once the PV is empty, this command removes it from the VG.
3. pvremove /dev/sdd1: This removes the LVM metadata from the disk, making it a plain block device again, ready to be physically removed from the server.

Conclusion

You have now mastered the fundamentals of LVM, a cornerstone of modern Linux storage management. You've moved beyond simple, static partitions into a world of flexible, dynamic volumes that are essential for the kinds of systems you manage as a DevOps engineer.

Key Takeaways:

• LVM abstracts physical storage into a flexible pool (PV -> VG -> LV).
• The primary workflow is pvcreate -> vgcreate -> lvcreate -> mkfs -> mount.
• To extend a volume, you extend the VG (vgextend), then the LV (lvextend), and finally the filesystem (resize2fs/xfs_growfs). The -r flag can simplify this.
• Safely removing a disk is a three-step process: pvmove, vgreduce, pvremove.

Preview of the Next Lesson:
In this lesson, we worked with partitions as the basis for our Physical Volumes. In the next lesson, we will dig deeper into the tools used to create and manage those partitions. The learning outcome will be to manage disk partitions using fdisk or parted and create, mount, and manage filesystems (ext4, xfs). This will complete your knowledge of the full storage stack, from raw disk to mounted filesystem.