Cómo particionar discos en Linux con fdisk, parted y gdisk

fdisk, parted y gdisk son las tres herramientas clásicas para crear y modificar tablas de particiones en Linux. Las tres hacen lo mismo con enfoques distintos: fdisk es interactivo y está en cualquier sistema, parted se puede usar en una sola línea desde scripts y gdisk (con su versión no interactiva sgdisk) está pensado exclusivamente para GPT. En este tutorial prepararás un disco secundario vacío en Ubuntu 24.04 con cualquiera de ellas, le darás formato ext4 y lo montarás de forma permanente.

Requisitos previos

• Un servidor con Ubuntu 24.04 LTS, por ejemplo un VPS o servidor dedicado de CubePath, con un disco adicional vacío (en los ejemplos, /dev/vdb).
• Un usuario no root con privilegios sudo.
• Una copia de seguridad reciente si el disco contiene algo que quieras conservar.

Advertencia

crear una tabla de particiones nueva destruye el acceso a todos los datos del disco. Comprueba dos veces el nombre del dispositivo antes de cada comando. Nunca trabajes sobre el disco donde está montado /.

Los comandos son idénticos en Debian 12. En Rocky Linux 9 cambian solo los nombres de paquete (dnf install parted gdisk).

Paso 1: Identificar el disco

Lista los dispositivos de bloque con su tamaño, tipo y punto de montaje:

lsblk -o NAME,SIZE,TYPE,FSTYPE,MOUNTPOINTS

NAME    SIZE TYPE FSTYPE MOUNTPOINTS
vda      40G disk
├─vda1   39G part ext4   /
├─vda14   4M part
├─vda15 106M part vfat   /boot/efi
└─vda16 913M part ext4   /boot
vdb      50G disk

En este ejemplo vda es el disco del sistema y vdb es el disco nuevo: no tiene particiones, ni sistema de archivos, ni punto de montaje. Según el hardware o el hipervisor, el disco puede llamarse /dev/sdb (SATA, SAS o virtio-scsi), /dev/vdb (virtio-blk) o /dev/nvme1n1 (NVMe, cuyas particiones se nombran nvme1n1p1).

Para asegurarte de que el disco no conserva firmas de un uso anterior (una tabla de particiones vieja, un superbloque RAID o LVM), consúltalas sin borrar nada:

sudo wipefs /dev/vdb

Si el comando no imprime nada, el disco está limpio. Si muestra firmas y estás seguro de que puedes borrarlas, elimínalas:

sudo wipefs -a /dev/vdb

MBR o GPT

Usa GPT salvo que tengas un motivo concreto para no hacerlo. MBR solo admite discos de hasta 2 TiB y cuatro particiones primarias, mientras que GPT admite discos mucho mayores, 128 particiones por defecto y guarda una copia de la tabla al final del disco. Todos los ejemplos de esta guía usan GPT.

Elige uno de los tres métodos de los pasos 2, 3 o 4. El resultado es el mismo: una única partición /dev/vdb1 que ocupa todo el disco.

Paso 2: Particionar con fdisk (interactivo)

fdisk viene instalado en Ubuntu. Ábrelo sobre el disco:

sudo fdisk /dev/vdb

Dentro del programa, cada orden es una letra. Las que vas a usar son:

Crea la tabla GPT con g:

Command (m for help): g
Created a new GPT disklabel (GUID: 6E1B2A5C-...).

Crea la partición con n y pulsa Enter en las tres preguntas para aceptar los valores por defecto (partición 1, primer sector alineado a 1 MiB y último sector al final del disco):

Command (m for help): n
Partition number (1-128, default 1):
First sector (2048-104857566, default 2048):
Last sector, +/-sectors or +/-size{K,M,G,T,P} (2048-104857566, default 104855551):

Created a new partition 1 of type 'Linux filesystem' and of size 50 GiB.

Si quisieras una partición más pequeña, en la pregunta del último sector escribirías un tamaño relativo, por ejemplo +20G.

El tipo por defecto, Linux filesystem, es el correcto para ext4 o XFS. Si la partición va a formar parte de LVM o de un RAID con mdadm, cámbialo con t y escribe el alias lvm o raid.

Revisa el resultado con p y guarda con w:

Command (m for help): w
The partition table has been altered.
Calling ioctl() to re-read partition table.
Syncing disks.

Hasta que pulsas w, nada se escribe en el disco: si te equivocas, sal con q y vuelve a empezar.

Paso 3: Particionar con parted (una línea)

parted aplica cada cambio en el momento, sin paso de confirmación final, y acepta las órdenes como argumentos. Eso lo hace ideal para scripts y para automatizar el aprovisionamiento. Viene instalado en Ubuntu Server; si no lo tienes, instálalo con sudo apt install parted.

Crea la tabla GPT y una partición que ocupe todo el disco:

sudo parted -s -a optimal /dev/vdb mklabel gpt mkpart datos ext4 0% 100%

• -s ejecuta en modo script, sin preguntas.
• -a optimal alinea la partición según la geometría que informa el disco.
• En GPT, el primer argumento de mkpart es el nombre de la partición (datos) y el segundo un tipo orientativo; parted no crea el sistema de archivos.
• 0% 100% usa porcentajes, así parted elige un inicio correctamente alineado.

Comprueba la tabla y la alineación:

sudo parted /dev/vdb print
sudo parted /dev/vdb align-check optimal 1

Model: Virtio Block Device (virtblk)
Disk /dev/vdb: 53.7GB
Sector size (logical/physical): 512B/512B
Partition Table: gpt
Disk Flags:

Number  Start   End     Size    File system  Name   Flags
 1      1049kB  53.7GB  53.7GB               datos

1 aligned

Para marcar la partición como LVM o RAID, usa sudo parted /dev/vdb set 1 lvm on o set 1 raid on.

Advertencia

parted no pide confirmación en modo script. Un mklabel sobre el disco equivocado borra su tabla de particiones al instante.

Paso 4: Particionar con gdisk o sgdisk

gdisk imita la interfaz de fdisk pero trabaja solo con GPT, y sgdisk ofrece lo mismo por línea de comandos. Instala el paquete, que incluye ambos:

sudo apt install gdisk

Con sgdisk, crea la partición 1 desde el primer sector disponible hasta el final del disco, con tipo 8300 (Linux filesystem) y nombre datos:

sudo sgdisk -o -n 1:0:0 -t 1:8300 -c 1:datos /dev/vdb

• -o crea una tabla GPT nueva y vacía.
• -n 1:0:0 define la partición 1; los ceros significan "valor por defecto" para inicio y fin.
• -t 1:8300 fija el tipo. Otros códigos habituales: 8e00 (LVM), fd00 (RAID), 8200 (swap), ef00 (partición EFI).
• -c 1:datos asigna el nombre.

Muestra el resultado:

sudo sgdisk -p /dev/vdb

Disk /dev/vdb: 104857600 sectors, 50.0 GiB
...
Number  Start (sector)    End (sector)  Size       Code  Name
   1            2048       104857566   50.0 GiB    8300  datos

Si prefieres el modo interactivo, sudo gdisk /dev/vdb acepta las mismas órdenes que fdisk (o para tabla nueva, n, t, p, w), con la diferencia de que los tipos se indican con los códigos hexadecimales anteriores. Si abres con gdisk un disco que tiene tabla MBR, lo convierte a GPT en memoria y solo lo escribe si confirmas con w. No hagas esa conversión en un disco de arranque sin preparar antes el gestor de arranque.

Paso 5: Hacer que el kernel lea la nueva tabla

Las tres herramientas avisan al kernel al guardar. Si el disco estaba en uso o ves un aviso del tipo Re-reading the partition table failed, fuerza la relectura:

sudo partprobe /dev/vdb

Comprueba que la partición existe:

lsblk /dev/vdb

NAME   MAJ:MIN RM SIZE RO TYPE MOUNTPOINTS
vdb    252:16   0  50G  0 disk
└─vdb1 252:17   0  50G  0 part

Paso 6: Crear el sistema de archivos

Una partición vacía no se puede montar hasta que tenga un sistema de archivos. ext4 es la opción por defecto en Ubuntu y Debian; la opción -L le pone una etiqueta legible:

sudo mkfs.ext4 -L datos /dev/vdb1

Creating filesystem with 13106688 4k blocks and 3276800 inodes
...
Writing superblocks and filesystem accounting information: done

Si prefieres XFS (el predeterminado en Rocky Linux y RHEL), usa sudo mkfs.xfs -L datos /dev/vdb1. La guía sobre ext4, XFS y Btrfs explica cuándo conviene cada uno.

Paso 7: Montar la partición de forma persistente

Crea el punto de montaje y monta la partición para probarla:

sudo mkdir -p /mnt/datos
sudo mount /dev/vdb1 /mnt/datos
df -h /mnt/datos

Filesystem      Size  Used Avail Use% Mounted on
/dev/vdb1        49G   24K   47G   1% /mnt/datos

Los nombres como /dev/vdb1 pueden cambiar si añades o quitas discos, así que en /etc/fstab usarás el UUID. Obtenlo con blkid:

sudo blkid /dev/vdb1

/dev/vdb1: LABEL="datos" UUID="3f6c1d8e-5a2b-4c7e-9d10-2b8f4e6a7c91" BLOCK_SIZE="4096" TYPE="ext4" PARTLABEL="datos" PARTUUID="..."

Abre /etc/fstab:

sudo nano /etc/fstab

Añade al final una línea con tu UUID:

UUID=3f6c1d8e-5a2b-4c7e-9d10-2b8f4e6a7c91  /mnt/datos  ext4  defaults,nofail  0  2

nofail evita que el servidor se quede detenido en el arranque si el disco no aparece, y el 2 final indica que fsck lo revise después del sistema raíz.

Desmonta, recarga systemd para que lea el fstab modificado y vuelve a montar todo a partir del archivo:

sudo umount /mnt/datos
sudo systemctl daemon-reload
sudo mount -a
findmnt /mnt/datos

TARGET     SOURCE    FSTYPE OPTIONS
/mnt/datos /dev/vdb1 ext4   rw,relatime

Si mount -a no da errores y findmnt muestra la partición, la configuración sobrevivirá a un reinicio. También puedes validar la sintaxis de todo el archivo con sudo findmnt --verify.

Otras operaciones habituales

Borrar una partición

Desmonta la partición y elimina su línea de /etc/fstab antes de borrarla. Después, con parted:

sudo parted /dev/vdb rm 1

Con fdisk, usa la orden d, elige el número de partición y guarda con w.

Ampliar la última partición

Si el disco ha crecido (por ejemplo, tras ampliarlo en el hipervisor), puedes extender la última partición hasta el final del disco con parted:

sudo parted /dev/vdb resizepart 1 100%

Después amplía el sistema de archivos: sudo resize2fs /dev/vdb1 para ext4, o sudo xfs_growfs /mnt/datos para XFS montado. Ambos funcionan con el sistema de archivos montado. Para discos con LVM, sigue la guía específica de ampliación de LVM.

Comparativa de fdisk, parted y gdisk

Para trabajo manual puntual, fdisk es el más cómodo porque nada se escribe hasta el final. Para scripts y aprovisionamiento, parted o sgdisk. Para reparar o convertir tablas GPT, gdisk.

Solución de problemas

mkfs o fdisk dicen que el dispositivo está en uso. Algo tiene la partición abierta: un montaje, LVM o un array RAID. Revisa lsblk y findmnt, desmonta con sudo umount y, si es LVM, desactiva el grupo con sudo vgchange -an nombre_vg.

La partición nueva no aparece en lsblk. Ejecuta sudo partprobe /dev/vdb. Si el disco está montado o en uso, el kernel no puede releer la tabla hasta que lo liberes o reinicies.

mount -a falla después de editar /etc/fstab. Suele ser un UUID mal copiado o un tipo de sistema de archivos incorrecto. Compara la línea con la salida de sudo blkid y corrígela antes de reiniciar.

Conclusión

Has creado una tabla GPT en un disco nuevo con fdisk, parted o sgdisk, le has dado formato ext4 y lo has montado por UUID para que persista tras reiniciar. Como siguientes pasos, puedes usar la partición como volumen físico de LVM para poder ampliarla más adelante, combinar varios discos en un RAID con mdadm o comparar ext4, XFS y Btrfs para elegir el sistema de archivos más adecuado.