Demystifying Linux Disk Partitioning with parted: A Practical Guide

Introduction

Disk partitioning is a foundational skill for system administrators, developers, and VPS operators. Whether provisioning a new virtual machine, preparing a disk for multiple operating systems, or optimizing storage for databases, understanding how to manipulate partitions safely is essential. This article provides a practical, in-depth walkthrough of disk partitioning using parted, a robust and scriptable tool widely available on Linux distributions. The goal is to demystify common concepts, demonstrate actionable commands, and offer guidance for real-world scenarios.

Why parted?

parted (GNU Parted) is a command-line utility designed to handle disk partitioning tasks for both MBR and GPT partition tables. Unlike simpler tools, parted supports large disks, advanced partition types, and scripting through non-interactive mode, making it suitable for VPS environments and automation pipelines. It also handles alignment, sector unit conversions, and can create filesystems in a basic way, although many admins prefer to use dedicated filesystem tools afterward.

Key capabilities

• Create, resize, move, and delete partitions on MBR and GPT disks.
• Set partition flags such as boot, esp, raid, lvm, and bios_grub.
• Support for very large disks beyond 2TiB using GPT.
• Non-interactive mode for scripting via the -s or –script flag.

Core concepts: MBR vs GPT, sectors, alignment

Before manipulating partitions, grasp the following fundamentals:

MBR vs GPT

MBR (Master Boot Record) is legacy and limited to disks up to ~2TiB and four primary partitions (one of which can be an extended partition containing logical partitions). GPT (GUID Partition Table) is modern, supports very large disks, many partitions, and stores redundant header information. For contemporary VPS and servers, GPT is generally the recommended choice.

Sectors and alignment

Disk space is measured in sectors. Modern drives and SSDs, as well as cloud/block devices, benefit from partition alignment to avoid performance penalties. Partition alignment is often defined in MiB (e.g., 1MiB) for compatibility. parted makes alignment easy by using units like MiB or aligning to the optimal boundary with mkpart defaults, but explicit specification is safer when scripting.

Practical parted workflow

Below is a typical lifecycle when working with a new disk or partitioning an existing virtual disk.

1. Inspect the disk

Start by examining the device: parted -l lists all recognized block devices and their partition tables. To inspect a specific disk, use parted /dev/sdX print (replace /dev/sdX with your device). This output shows the partition table type, disk size, sector size, and individual partition start/stop positions.

2. Create a partition table

To create a GPT table non-interactively: parted /dev/sdX –script mklabel gpt. For MBR use: mklabel msdos. Note that this operation destroys existing table and partition metadata, so ensure backups or unmounted volumes.

3. Create partitions

Creating aligned partitions: parted /dev/sdX –script mkpart primary ext4 1MiB 50GiB. This creates a primary partition starting at 1MiB and ending at 50GiB. For a second partition: mkpart primary ext4 50GiB 100% to fill remaining space. Use set to set flags, for example: parted /dev/sdX set 1 boot on or set 2 lvm on for LVM PVs.

4. Filesystem creation

parted does not always create filesystems for production use. After creating a partition such as /dev/sdX1, use filesystem tools: mkfs.ext4 /dev/sdX1, mkfs.xfs /dev/sdX1, or for swap: mkswap /dev/sdX2. For encrypted volumes, initialize the LUKS container before filesystem creation.

5. Resizing and moving partitions

Resizing can be risky. For non-destructive expansion of a filesystem within a partition you generally must:

• Resize the filesystem (if the filesystem supports online growth), e.g., resize2fs for ext4, or xfs_growfs for XFS (requires mounting).
• Use parted to resize the partition boundaries: parted /dev/sdX –script resizepart N END (where END is new end coordinate).
• If shrinking, resize the filesystem first to be smaller than the desired partition size, then shrink the partition. Always ensure backups.

Example sequence to extend an ext4 filesystem using free space to the end of the disk:

parted /dev/sdX –script resizepart 1 100% then resize2fs /dev/sdX1 (if ext4). If the partition holds LVM PVs, use pvresize instead to expand logical volumes.

Advanced use cases

LVM and parted

When using LVM, create a partition and set the lvm flag. Then initialize with pvcreate /dev/sdX1, create volume groups and logical volumes. For cloud VPS setups, LVM is popular for flexible volume management. parted’s role is to prepare the underlying block device with proper alignment and flags.

RAID and metadata

Software RAID (mdadm) often prefers whole-disk devices (/dev/sdX) or partitions with the raid flag. Use parted to create partitions with desired sizes and set the raid flag. For advanced RAID level metadata placement, be mindful of metadata offsets which can interact with alignment.

EFI system partitions (ESP)

For UEFI booting, create a small FAT32 partition (commonly 512MiB) and set the esp flag: parted /dev/sdX –script mkpart primary fat32 1MiB 513MiB followed by parted /dev/sdX set 1 esp on. Format with mkfs.fat -F32 /dev/sdX1.

Loopback images and virtualization

parted can operate on loop devices (disk images) used for virtual machines or container images. Create a file, attach it with losetup, and use parted to partition the image. This is useful for creating cloud images or preparing templates.

Safety, recovery, and best practices

Partitioning carries risk. Follow these guidelines to reduce the chance of data loss:

• Always back up critical data before modifying partition tables.
• Work on unmounted filesystems whenever possible. For root partitions, use a rescue environment or live ISO.
• Prefer GPT for modern systems and large disks; reserve small offsets (1MiB) for alignment.
• Use –script in automation to avoid prompts. Check the exit codes to detect failures.
• Keep a copy of the original partition table with tools like sfdisk –dump /dev/sdX > partition-table.dump for MBR or use sgdisk –backup for GPT.
• When resizing, always shrink the filesystem first (if supported) before shrinking the partition, and grow the partition first before expanding the filesystem.

Comparing parted with other tools

There are several tools for partitioning — fdisk, gdisk, sgdisk, cfdisk, and graphical tools. Choose based on needs:

• fdisk/cfdisk: Good for MBR and quick tasks; older feature set.
• gdisk/sgdisk: Focused on GPT with GPT-specific features and scripting.
• parted: Versatile for both MBR and GPT, handles large disks and unit-flexible commands; suitable for scripting.

For scripting in cloud-init or provisioning systems, parted’s non-interactive mode is especially useful. For complex GPT manipulations like GUID edits or recovery of GPT headers, gdisk/sgdisk might offer more detailed options.

Example scenarios

Scenario A: Prepare a 50GiB VPS disk with root and data partitions

• Initialize GPT: parted /dev/vda –script mklabel gpt
• Create a 20GiB root partition starting at 1MiB: mkpart primary ext4 1MiB 20GiB
• Create a 30GiB data partition: mkpart primary ext4 20GiB 100%
• Format: mkfs.ext4 /dev/vda1 and mkfs.ext4 /dev/vda2

Scenario B: Add a new disk for LVM

• Partition the new disk with a single partition aligned to 1MiB and set lvm flag: parted /dev/vdb –script mklabel gpt mkpart primary 1MiB 100% set 1 lvm on
• Initialize LVM: pvcreate /dev/vdb1 then vgextend vgname /dev/vdb1

Conclusion

Understanding parted equips you to manage storage reliably in VPS and server contexts. The tool’s ability to handle GPT and large disks, combined with scriptable operation, makes it ideal for deployment automation and day-to-day administration. Follow the recommended safety practices: always back up, work on unmounted volumes when possible, and favor GPT with modern alignment defaults.

For hosting-oriented tasks—such as provisioning and managing virtual disks on cloud-based infrastructure—choosing a reliable VPS provider simplifies the environment in which you apply these skills. If you’re evaluating options, consider solutions that provide predictable disk performance and flexible instance sizes. For example, VPS.DO offers a range of virtual server configurations in the USA; see their USA VPS plans at https://vps.do/usa/. For more about the provider, visit https://vps.do/.