Gestionar particiones y sistemas de archivos en Linux | CompTIA Linux+

Introducción

En este laboratorio, aprenderás las habilidades fundamentales necesarias para gestionar particiones de disco y sistemas de archivos en un entorno Linux. Trabajarás con utilidades de línea de comandos como fdisk para inspeccionar los discos disponibles, crear nuevas particiones y formatearlas con un sistema de archivos estándar. Para garantizar una experiencia de aprendizaje segura, todas las operaciones se realizarán en un disco virtual secundario dedicado, /dev/sdb, dejando intacto el disco principal del sistema operativo.

Nota: En este entorno de laboratorio, /dev/sdb se implementa como un dispositivo de bucle (loop device, un archivo que actúa como un disco). Cuando crees particiones, aparecerán con nombres como loop13p1, pero crearás enlaces simbólicos para acceder a ellas como /dev/sdb1, /dev/sdb2, etc., tal como lo harías con hardware real.

A lo largo de los ejercicios, crearás una partición estándar de Linux, la formatearás con el sistema de archivos ext4 y aprenderás a montarla para su uso inmediato. Luego, configurarás el sistema para montar este sistema de archivos automáticamente al arrancar editando el archivo /etc/fstab. Finalmente, ampliarás tus habilidades creando y gestionando una partición de intercambio (swap) dedicada, un componente crítico para el rendimiento del sistema.

Inspeccionar discos y crear una nueva partición de Linux con fdisk

En este paso, aprenderás a inspeccionar los discos disponibles y sus tablas de particiones. Luego, utilizarás la utilidad fdisk, una potente herramienta de línea de comandos, para crear una nueva partición en un disco secundario. En un escenario real, debes tener mucho cuidado al modificar particiones, ya que los errores pueden provocar la pérdida de datos. Para este laboratorio, trabajaremos en un disco virtual dedicado, /dev/sdb, para asegurar que el disco principal del sistema operativo (/dev/sda) permanezca intacto.

Primero, obtengamos una visión general de todos los dispositivos de bloque (discos y particiones) conectados a tu sistema. El comando lsblk proporciona una vista clara, similar a un árbol.

lsblk

La salida te mostrará los discos disponibles, incluido tu disco principal del sistema (vda) y un dispositivo de bucle (loop13) que representa nuestro disco virtual para este laboratorio.

NAME       MAJ:MIN RM   SIZE RO TYPE MOUNTPOINTS
...
loop13       7:13   0     2G  0 loop
vda        252:0    0    40G  0 disk
├─vda1     252:1    0     1M  0 part
├─vda2     252:2    0   200M  0 part /boot/efi
└─vda3     252:3    0  39.8G  0 part /

Observa que el dispositivo de bucle (al que se puede acceder como /dev/sdb a través de un enlace simbólico) es un disco virtual de 2GB sin particiones todavía. Ahora, usemos fdisk para obtener una mirada más detallada a la tabla de particiones de /dev/sdb. El indicador -l lista las tablas de particiones para los dispositivos especificados y luego sale. Dado que fdisk requiere privilegios de root para inspeccionar información a nivel de disco, debes usar sudo.

sudo fdisk -l /dev/sdb

La salida proporciona detalles sobre el disco, incluidos su tamaño, sectores e identificador. Como aún no hay particiones, la lista de dispositivos en la parte inferior estará vacía.

Disk /dev/sdb: 2 GiB, 2147483648 bytes, 4194304 sectors
Units: sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes

Nota: Si es la primera vez que usas el disco, es posible que veas un mensaje sobre la creación de una nueva etiqueta de disco DOS.

A continuación, iniciarás fdisk en su modo interactivo para crear una nueva partición. Este proceso implica una secuencia de comandos de una sola letra. Ejecuta el siguiente comando para comenzar a gestionar /dev/sdb:

sudo fdisk /dev/sdb

Ahora estás dentro de la utilidad fdisk, indicada por el prompt Command (m for help):. Sigue estos pasos cuidadosamente:

Crear una nueva partición: Escribe n y presiona Enter.
Elegir el tipo de partición: Se te pedirá que selecciones un tipo de partición (primaria o extendida). El valor predeterminado es primaria (p), que es lo que queremos. Presiona Enter para aceptar el valor predeterminado.
Elegir el número de partición: El valor predeterminado es 1, ya que esta es la primera partición. Presiona Enter para aceptarlo.
Especificar el primer sector: El valor predeterminado es el primer sector disponible en el disco. Esta es casi siempre la elección correcta. Presiona Enter para aceptar el valor predeterminado.
Especificar el último sector o tamaño: En lugar de calcular sectores, puedes especificar un tamaño legible por humanos. Creemos una partición de 500MB. Escribe +500M y presiona Enter.
Imprimir la tabla de particiones en memoria: Antes de guardar, es una buena práctica revisar tus cambios. Escribe p y presiona Enter para ver el nuevo diseño de particiones. Deberías ver un nuevo dispositivo, /dev/sdb1.
Escribir los cambios en el disco: Los cambios que has realizado solo están en la memoria. Para guardarlos en la tabla de particiones del disco, escribe w y presiona Enter. Esto escribirá los cambios y saldrá de fdisk.

Aquí tienes un resumen de la sesión interactiva:

Welcome to fdisk (util-linux 2.37.2).
Changes will remain in memory only, until you decide to write them.
Be careful before using the write command.

Device does not contain a recognized partition table.
Created a new DOS disklabel with disk identifier 0x54041549.

Command (m for help): n
Partition type
   p   primary (0 primary, 0 extended, 4 free)
   e   extended (container for logical partitions)
Select (default p): p
Partition number (1-4, default 1): 1
First sector (2048-4194303, default 2048):
Last sector, +/-sectors or +/-size{K,M,G,T,P} (2048-4194303, default 4194303): +500M

Created a new partition 1 of type 'Linux' and of size 500 MiB.

Command (m for help): p
Disk /dev/sdb: 2 GiB, 2147483648 bytes, 4194304 sectors
Units: sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disklabel type: dos
Disk identifier: 0x54041549

Device     Boot Start     End Sectors  Size Id Type
/dev/sdb1        2048 1026047 1024000  500M 83 Linux

Command (m for help): w
The partition table has been altered.
Calling ioctl() to re-read partition table.
Re-reading the partition table failed.: Invalid argument

The kernel still uses the old table. The new table will be used at the next reboot or after you run partprobe(8) or partx(8).

Después de escribir la tabla de particiones, es posible que notes un mensaje que indica que el kernel no pudo volver a leer la tabla de particiones inmediatamente. Esto es normal cuando se trabaja con dispositivos de bucle. El comando partprobe solicita al kernel del sistema operativo que vuelva a leer la tabla de particiones.

sudo partprobe

Ahora, verifica que el sistema reconozca la nueva partición ejecutando lsblk nuevamente.

lsblk /dev/sdb

La salida debería mostrar el dispositivo de bucle y su nueva partición. Debido a la configuración del dispositivo de bucle, la partición aparecerá como loop13p1:

NAME       MAJ:MIN RM  SIZE RO TYPE MOUNTPOINTS
loop13       7:13   0    2G  0 loop
└─loop13p1 259:0    0  500M  0 part

Dado que la partición aparece como loop13p1 pero el laboratorio necesita /dev/sdb1 para funcionar, debemos crear un enlace simbólico para la partición. Primero, identifiquemos el dispositivo de partición real. El patrón p1$ asegura que solo coincida con el nombre de la partición, no con el dispositivo de bucle principal:

PARTITION_DEVICE=$(lsblk -lno NAME /dev/sdb | grep -E "p1$" | head -1)
echo "Partition device: /dev/$PARTITION_DEVICE"

Ahora crea un enlace simbólico para la partición:

sudo ln -s /dev/$PARTITION_DEVICE /dev/sdb1

Verifica que /dev/sdb1 ahora funcione:

lsblk /dev/sdb1

La salida ahora debería mostrar la partición accesible como /dev/sdb1:

NAME       MAJ:MIN RM  SIZE RO TYPE MOUNTPOINTS
loop13p1   259:0    0  500M  0 part

Has creado con éxito una nueva partición de Linux de 500MB en /dev/sdb y la has hecho accesible como /dev/sdb1.

Crear y formatear un sistema de archivos ext4 con mkfs.ext4

En este paso, formatearás la nueva partición que creaste, /dev/sdb1, con un sistema de archivos. Un sistema de archivos proporciona la estructura necesaria para almacenar y organizar archivos y directorios. Sin un sistema de archivos, el sistema operativo no puede leer ni escribir en la partición. Usaremos ext4, que es el sistema de archivos predeterminado y más utilizado para las distribuciones modernas de Linux debido a su rendimiento, fiabilidad y características.

El comando para crear un sistema de archivos es mkfs, que significa "make filesystem" (crear sistema de archivos). Es una interfaz para varios constructores específicos de sistemas de archivos, como mkfs.ext4, mkfs.xfs, etc. Usaremos mkfs.ext4 directamente. Esta operación es destructiva y borrará cualquier dato existente en la partición, por lo que requiere privilegios de sudo.

Para formatear la partición /dev/sdb1 con el sistema de archivos ext4, ejecuta el siguiente comando:

sudo mkfs.ext4 /dev/sdb1

El comando creará el sistema de archivos y mostrará información sobre el proceso, incluido el UUID del sistema de archivos, el tamaño del bloque y el recuento de inodos.

mke2fs x.xx.x (xx-xxx-xxxx)
Creating filesystem with 128000 4k blocks and 32000 inodes
Filesystem UUID: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
Superblock backups stored on blocks:
 32768, 98304

Allocating group tables: done
Writing inode tables: done
Creating journal (4096 blocks): done
Writing superblocks and filesystem accounting information: done

Después de formatear, puedes verificar que el sistema de archivos se haya creado correctamente. El comando blkid es una gran herramienta para esto, ya que imprime los atributos de los dispositivos de bloque, incluido su tipo de sistema de archivos.

sudo blkid /dev/sdb1

La salida debería mostrar claramente que /dev/sdb1 ahora tiene un TYPE de ext4.

/dev/sdb1: UUID="xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" BLOCK_SIZE="4096" TYPE="ext4" PARTUUID="1a2b3c4d-01"

Para una vista más detallada, puedes usar el comando dumpe2fs con el indicador -h para mostrar la información del superbloque. El superbloque contiene metadatos críticos sobre el sistema de archivos.

sudo dumpe2fs -h /dev/sdb1

Este comando producirá mucha salida. Busca líneas clave como Filesystem magic number y Filesystem state para confirmar la integridad del sistema de archivos.

dumpe2fs x.xx.x (xx-xxx-xxxx)
Filesystem volume name:   <none>
Last mounted on:          <not available>
Filesystem UUID:          xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
Filesystem magic number:  0xEF53
Filesystem revision #:    1 (dynamic)
Filesystem features:      has_journal ext_attr resize_inode dir_index filetype extent 64bit flex_bg sparse_super large_file huge_file dir_nlink extra_isize
Filesystem flags:         signed_directory_hash
Default mount options:    user_xattr acl
Filesystem state:         clean
...

Ahora has formateado con éxito la partición, y está lista para ser montada y utilizada para almacenar datos.

Montar, probar y desmontar el sistema de archivos

En este paso, aprenderás cómo hacer que tu sistema de archivos recién formateado sea accesible para el sistema operativo. Este proceso se llama "montaje" (mounting). El montaje conecta el sistema de archivos en un dispositivo (como /dev/sdb1) a un directorio específico en el árbol del sistema de archivos, conocido como "punto de montaje". Una vez montado, puedes interactuar con la partición como con cualquier otro directorio.

Primero, necesitas crear un punto de montaje. Esto es simplemente un directorio vacío. Es una práctica estándar crear puntos de montaje temporales bajo el directorio /mnt. Creemos un directorio llamado /mnt/data. Dado que /mnt es un directorio del sistema, necesitarás sudo.

sudo mkdir /mnt/data

Ahora, usa el comando mount para conectar la partición /dev/sdb1 al directorio /mnt/data.

sudo mount /dev/sdb1 /mnt/data

Para verificar que el sistema de archivos esté montado, primero verifiquemos si el comando de montaje tuvo éxito comprobando el estado del montaje. Usaremos varios comandos para verificar el montaje:

## Comprobar si el punto de montaje tiene el sistema de archivos montado
mountpoint /mnt/data

Si el montaje fue exitoso, deberías ver:

/mnt/data is a mountpoint

Ahora verifiquemos el uso del disco con df. Debido a la configuración del dispositivo de bucle, la partición podría aparecer con su nombre de dispositivo real en lugar del nombre del enlace simbólico:

df -h /mnt/data

Deberías ver una entrada que muestra el sistema de archivos montado:

Filesystem      Size  Used Avail Use% Mounted on
/dev/loop13p1   488M  2.6M  459M   1% /mnt/data

También puedes verificar con el comando mount:

mount | grep /mnt/data

Esto debería mostrar:

/dev/loop13p1 on /mnt/data type ext4 (rw,relatime)

Ahora, probemos si podemos escribir datos en nuestro nuevo sistema de archivos. Primero, verifiquemos la propiedad y los permisos actuales del punto de montaje:

ls -ld /mnt/data

Deberías ver algo como:

drwxr-xr-x 3 root root 4096 Dec 12 10:00 /mnt/data

Ahora intenta crear un archivo en el punto de montaje:

touch /mnt/data/testfile

Este comando probablemente fallará con un error de "Permiso denegado". Esto se debe a que el directorio raíz del sistema de archivos montado es propiedad del usuario root. Para solucionar esto, cambia la propiedad del punto de montaje a tu usuario actual, labex:

sudo chown labex:labex /mnt/data

Ahora, intenta crear el archivo de nuevo:

touch /mnt/data/testfile

Esta vez, el comando debería tener éxito. Verifica que el archivo se haya creado:

ls -l /mnt/data

Deberías ver:

total 16
drwx------ 2 root  root  16384 Dec 12 10:00 lost+found
-rw-r--r-- 1 labex labex     0 Dec 12 10:05 testfile

El directorio lost+found es una característica estándar de los sistemas de archivos ext4, utilizada para recuperar archivos en caso de corrupción del sistema de archivos.

Cuando termines de usar el sistema de archivos, debes desmontarlo usando el comando umount. Es importante tener en cuenta que no puedes desmontar un sistema de archivos si está en uso actualmente, por ejemplo, si tu directorio de trabajo actual está dentro del punto de montaje. Veamos esto en acción.

Primero, cambia tu directorio a /mnt/data:

cd /mnt/data

Ahora, intenta desmontarlo. Puedes referirte a un sistema de archivos por su nombre de dispositivo o por su punto de montaje.

sudo umount /mnt/data

Recibirás un mensaje de error indicando que el objetivo está ocupado.

umount: /mnt/data: target is busy.

Para desmontarlo con éxito, primero debes navegar fuera del directorio. Volvamos a tu directorio de inicio.

cd ~

Ahora, ejecuta el comando umount de nuevo.

sudo umount /mnt/data

El comando debería ejecutarse sin ninguna salida. Puedes verificar que ya no está montado ejecutando el comando mountpoint:

mountpoint /mnt/data

Deberías ver:

/mnt/data is not a mountpoint

Finalmente, puedes limpiar eliminando el directorio del punto de montaje:

sudo rmdir /mnt/data

Nota de solución de problemas: Si encuentras problemas con el comando de montaje que no funciona, puedes intentar montar usando el nombre real del dispositivo de bucle en lugar del enlace simbólico:

## Encontrar el nombre real del dispositivo
ACTUAL_DEVICE=$(readlink -f /dev/sdb1)
echo "Actual device: $ACTUAL_DEVICE"

## Montar usando el nombre real del dispositivo
sudo mkdir /mnt/data
sudo mount $ACTUAL_DEVICE /mnt/data

Configurar el montaje persistente en /etc/fstab

En este paso, aprenderás cómo hacer que tu sistema de archivos se monte automáticamente cada vez que el sistema arranca. El comando mount que usaste en el paso anterior es temporal; el montaje se perderá después de un reinicio. Para crear un montaje persistente, necesitas agregar una entrada a un archivo de configuración especial llamado /etc/fstab (tabla de sistemas de archivos).

El sistema lee /etc/fstab durante el proceso de arranque para determinar qué sistemas de archivos montar. Es un archivo crítico, por lo que siempre es una buena idea crear una copia de seguridad antes de editarlo.

Primero, creemos una copia de seguridad del archivo fstab actual.

sudo cp /etc/fstab /etc/fstab.bak

A continuación, necesitamos un punto de montaje permanente. En el paso anterior, usamos /mnt/data y luego lo eliminamos. Para montajes permanentes, es común crear un directorio en el sistema de archivos raíz. Creemos un directorio llamado /data.

sudo mkdir /data

Aunque puedes usar el nombre del dispositivo (/dev/sdb1) en /etc/fstab, no se recomienda. Los nombres de los dispositivos a veces pueden cambiar entre reinicios, especialmente si agregas o eliminas hardware. Un método mucho más confiable es usar el Identificador Único Universal (UUID) de la partición, que es una cadena única asignada al sistema de archivos cuando se creó y no cambia.

Para encontrar el UUID de /dev/sdb1, usa el comando blkid de nuevo:

sudo blkid /dev/sdb1

La salida mostrará el UUID. Copia este valor (sin las comillas).

/dev/sdb1: UUID="xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" BLOCK_SIZE="4096" TYPE="ext4" PARTUUID="1a2b3c4d-01"

Ahora, editarás /etc/fstab usando el editor nano. Debes usar sudo porque es un archivo del sistema.

sudo nano /etc/fstab

Ve al final del archivo y agrega una nueva línea para tu partición. El formato para una entrada en fstab es: <identificador_dispositivo> <punto_montaje> <tipo_sistema_archivos> <opciones> <dump> <pass>

Agrega la siguiente línea, reemplazando xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx con el UUID real que copiaste del comando blkid.

UUID=xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx /data ext4 defaults 0 2

UUID=...: Identifica la partición por su ID único.
/data: El directorio donde se montará el sistema de archivos.
ext4: El tipo de sistema de archivos.
defaults: Un conjunto estándar de opciones de montaje adecuado para la mayoría de los casos.
0: El campo dump. Este es un indicador de utilidad de copia de seguridad obsoleto y debería ser 0.
2: El campo pass. Esto le dice a la utilidad fsck el orden para verificar los sistemas de archivos al arrancar. 1 es para el sistema de archivos raíz, 2 es para otros sistemas de archivos permanentes, y 0 deshabilita la verificación.

Después de agregar la línea, guarda el archivo y sal de nano presionando Ctrl+X, luego Y, y luego Enter.

Ahora, en lugar de reiniciar para probar, puedes usar el comando mount -a. Este comando monta todos los sistemas de archivos listados en /etc/fstab que aún no están montados.

sudo mount -a

Si no hay errores, el comando se completará silenciosamente. Ahora puedes verificar que tu sistema de archivos esté montado correctamente usando el comando df.

df -h | grep /data

La salida debería confirmar que /dev/sdb1 está montado en /data.

/dev/sdb1       488M  2.6M  459M   1% /data

Tu partición ahora se montará automáticamente cada vez que el sistema se inicie.

Crear y gestionar una partición de intercambio (swap) de Linux

En este paso, aprenderás sobre otro tipo especial de partición: el intercambio (swap) de Linux. El espacio de intercambio es utilizado por el sistema operativo como memoria virtual cuando la RAM física está llena. Permite que el sistema mueva páginas de memoria inactivas al disco, liberando RAM para procesos activos. Aunque no es un sustituto de una RAM suficiente, tener una partición de intercambio puede evitar que el sistema se bloquee debido a errores de falta de memoria.

Nota importante: Antes de crear una nueva partición, asegúrate de que cualquier sistema de archivos existente en /dev/sdb esté desmontado. Si el dispositivo está montado actualmente (de los pasos anteriores), puedes encontrar errores de "Device or resource busy" (Dispositivo o recurso ocupado) al intentar modificar la tabla de particiones.

Crearemos una nueva partición en /dev/sdb y la configuraremos como espacio de intercambio. Primero, asegurémonos de que el dispositivo no esté montado, luego usemos fdisk para crear la partición. Ya hemos creado /dev/sdb1, por lo que esta nueva partición será /dev/sdb2.

## Primero, comprueba si el dispositivo está montado y desmóntalo si es necesario
lsblk /dev/sdb
sudo umount /data /mnt/data 2> /dev/null || true

## Ahora crea la partición
sudo fdisk /dev/sdb

Dentro del prompt interactivo de fdisk, sigue estos comandos:

Crear una nueva partición: Escribe n y presiona Enter.
Elegir el tipo y número de partición: Acepta los valores predeterminados para una partición primaria (p) y el número de partición 2 presionando Enter dos veces.
Especificar sectores: Acepta el primer sector predeterminado. Para el tamaño, creemos una partición de 256MB. Escribe +256M y presiona Enter.
Cambiar el tipo de partición: Este es el paso crucial. Escribe t para cambiar el tipo de una partición. Cuando se te solicite el número de partición, ingresa 2. Cuando se te solicite el código hexadecimal, ingresa 82, que corresponde a "Linux swap / Solaris".
Imprimir y verificar: Escribe p para revisar los cambios. Deberías ver /dev/sdb2 con su tipo listado como "Linux swap / Solaris".
Escribir cambios: Escribe w para guardar la nueva tabla de particiones y salir.

Command (m for help): n
Partition type
   p   primary (1 primary, 0 extended, 3 free)
   e   extended (container for logical partitions)
Select (default p): p
Partition number (2-4, default 2): 2
First sector (1026048-4194303, default 1026048):
Last sector, +/-sectors or +/-size{K,M,G,T,P} (1026048-4194303, default 4194303): +256M

Created a new partition 2 of type 'Linux' and of size 256 MiB.

Command (m for help): t
Partition number (1,2, default 2): 2
Hex code (type L to list all codes): 82

Changed type of partition 'Linux' to 'Linux swap / Solaris'.

Command (m for help): p
Disk /dev/sdb: 2 GiB, 2147483648 bytes, 4194304 sectors
...
Device     Boot   Start     End   Sectors   Size Id Type
/dev/sdb1          2048 1026047   1024000   500M 83 Linux
/dev/sdb2       1026048 1550335    524288   256M 82 Linux swap / Solaris

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

Después de crear la partición, necesitamos crear un enlace simbólico para /dev/sdb2 tal como lo hicimos para /dev/sdb1. Primero, ejecuta partprobe para asegurar que el kernel reconozca la nueva partición:

sudo partprobe

Ahora identifica y crea el enlace simbólico para la segunda partición:

PARTITION2_DEVICE=$(lsblk -lno NAME /dev/sdb | grep p2 | head -1)
sudo ln -s /dev/$PARTITION2_DEVICE /dev/sdb2

Verifica que la partición sea accesible:

lsblk /dev/sdb2

Antes de formatear la partición como espacio de intercambio, debemos asegurarnos de que el dispositivo no esté ocupado. Si encuentras un error de "Device or resource busy", significa que el dispositivo podría estar montado. Primero verifiquemos y desmontemos cualquier montaje existente:

## Comprobar el estado actual del montaje
lsblk /dev/sdb

## Si el dispositivo está montado, desmóntalo
sudo umount /data /mnt/data 2> /dev/null || true

Ahora que la partición está creada y accesible, necesitas formatearla para usarla como espacio de intercambio con el comando mkswap.

sudo mkswap /dev/sdb2

Después de formatear, puedes activar el espacio de intercambio. Primero, verifica el uso actual de intercambio con el comando free -h.

free -h

La salida probablemente mostrará 0B para Swap.

              total        used        free      shared  buff/cache   available
Mem:          1.9Gi       151Mi       1.6Gi       0.0Ki       202Mi       1.7Gi
Swap:            0B          0B          0B

Ahora, activa la nueva partición de intercambio usando el comando swapon.

sudo swapon /dev/sdb2

Verifica el uso de intercambio de nuevo con free -h y swapon -s (resumen).

free -h

              total        used        free      shared  buff/cache   available
Mem:          1.9Gi       152Mi       1.4Gi       0.0Ki       202Mi       1.6Gi
Swap:         256Mi          0B       256Mi

swapon -s

Filename    Type  Size Used Priority
/dev/sdb2                               partition 262140 0 -2

Puedes ver que el espacio total de intercambio ha aumentado. Para deshabilitar una partición de intercambio, usa el comando swapoff.

sudo swapoff /dev/sdb2

Verifica que se haya deshabilitado ejecutando free -h de nuevo. El espacio de intercambio volverá a cero. Esto demuestra cómo gestionar dinámicamente el espacio de intercambio en un sistema en ejecución.

Nota de solución de problemas: Si encuentras errores de "Device or resource busy" durante este paso, normalmente significa:

El dispositivo o una de sus particiones está montado actualmente
Un proceso está accediendo al dispositivo

Para resolver esto, asegúrate de que todos los puntos de montaje estén desmontados con sudo umount /data /mnt/data antes de continuar con las operaciones de partición.

Resumen

En este laboratorio, aprendiste las habilidades esenciales para gestionar particiones de disco y sistemas de archivos en un sistema Linux. Comenzaste inspeccionando los dispositivos de bloque disponibles usando lsblk y luego utilizaste la utilidad fdisk para crear una nueva partición primaria en un disco secundario. Después de la creación de la partición, la formateaste con el sistema de archivos ext4 usando mkfs.ext4. También practicaste el montaje del nuevo sistema de archivos en un directorio, verificando su estado y desmontándolo. Finalmente, configuraste el montaje persistente editando el archivo /etc/fstab con el UUID de la partición para asegurar que se monte automáticamente al arrancar el sistema.

Además, el laboratorio cubrió el proceso de creación y gestión de un espacio de intercambio dedicado. Esto implicó usar fdisk de nuevo para crear una partición y cambiar su tipo a "Linux swap". Luego preparaste esta partición como un área de intercambio con el comando mkswap y la activaste usando swapon. Para hacer que el espacio de intercambio sea persistente entre reinicios, también agregaste una entrada correspondiente al archivo /etc/fstab.