Administración de Particiones y Sistemas de Archivos en Linux

CompTIABeginner
Practicar Ahora

Introducción

En esta práctica de laboratorio, adquirirás las habilidades fundamentales necesarias para administrar 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 (un archivo que actúa como un disco). Al crear 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 que monte este sistema de archivos automáticamente al arrancar editando el archivo /etc/fstab. Finalmente, ampliarás tus conocimientos creando y administrando una partición de intercambio (swap) dedicada de Linux, un componente crítico para el rendimiento del sistema.

Este es un Laboratorio Guiado, que proporciona instrucciones paso a paso para ayudarte a aprender y practicar. Sigue las instrucciones cuidadosamente para completar cada paso y obtener experiencia práctica. Los datos históricos muestran que este es un laboratorio de nivel principiante con una tasa de finalización del 83%. Ha recibido una tasa de valoraciones positivas del 93% por parte de los alumnos.

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 ser extremadamente cuidadoso 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 en forma de árbol.

lsblk

La salida te mostrará los discos disponibles, incluyendo 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 (que es accesible como /dev/sdb a través de un enlace simbólico) es un disco virtual de 2 GB que aún no tiene particiones. Ahora, usemos fdisk para obtener una mirada más detallada de la tabla de particiones de /dev/sdb. La opción -l enumera las tablas de particiones de los dispositivos especificados y luego finaliza. Dado que fdisk requiere privilegios de superusuario para inspeccionar información a nivel de disco, debes usar sudo.

sudo fdisk -l /dev/sdb

La salida proporciona detalles sobre el disco, incluyendo 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 se usa el disco, es posible que veas un mensaje sobre la creación de una nueva etiqueta de disco (disklabel) 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 administrar /dev/sdb:

sudo fdisk /dev/sdb

Ahora te encuentras dentro de la utilidad fdisk, indicado por el prompt Command (m for help):. Sigue estos pasos cuidadosamente:

  1. Crear una nueva partición: Escribe n y presiona Enter.
  2. 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.
  3. Elegir el número de partición: El valor predeterminado es 1, ya que esta es la primera partición. Presiona Enter para aceptarlo.
  4. 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.
  5. Especificar el último sector o tamaño: En lugar de calcular sectores, puedes especificar un tamaño legible para humanos. Vamos a crear una partición de 500 MB. Escribe +500M y presiona Enter.
  6. Imprimir la tabla de particiones en memoria: Antes de guardar, es una buena práctica revisar los cambios. Escribe p y presiona Enter para ver el nuevo diseño de particiones. Deberías ver un nuevo dispositivo, /dev/sdb1.
  7. Escribir los cambios en el disco: Los cambios que has realizado aún están solo 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 indicando que el kernel no pudo releer inmediatamente la tabla de particiones. Esto es normal cuando se trabaja con dispositivos de bucle. El comando partprobe solicita que el kernel del sistema operativo 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 que /dev/sdb1 funcione, debemos crear un enlace simbólico para la partición. Primero, identifiquemos el dispositivo de partición real:

PARTITION_DEVICE=$(lsblk -lno NAME /dev/sdb | grep 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 500 MB 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, confiabilidad 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, incluyendo 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 excelente 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 la opción -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 información. 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". El montaje vincula el sistema de archivos de un dispositivo (como /dev/sdb1) a un directorio específico en el árbol de sistemas 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. Vamos a crear un directorio llamado /mnt/data. Como /mnt es un directorio del sistema, necesitarás sudo.

sudo mkdir /mnt/data

Ahora, usa el comando mount para vincular 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 comprobemos si el comando mount tuvo éxito revisando 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 revisemos 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

Es probable que este comando falle con un error de "Permiso denegado". Esto se debe a que el directorio raíz del sistema de archivos montado pertenece al 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 fue 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 hayas terminado 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á actualmente en uso, 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 ya sea 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 salir del directorio. Regresemos a tu directorio personal.

cd ~

Ahora, ejecuta el comando umount nuevamente.

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 resolución de problemas: Si encuentras problemas con el comando mount, 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 arranque. 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. Vamos a crear un directorio llamado /data.

sudo mkdir /data

Aunque puedes usar el nombre del dispositivo (/dev/sdb1) en /etc/fstab, no es recomendable. Los nombres de los dispositivos a veces pueden cambiar entre reinicios, especialmente si agregas o quitas 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 nuevamente:

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> <volcado> <pasada>

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 adecuadas para la mayoría de los casos.
  • 0: El campo dump. Esta es una bandera de utilidad de respaldo obsoleta y debe ser 0.
  • 2: El campo pass. Esto le indica 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 desactiva 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 enumerados 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 se inicie el sistema.

Crear y Administrar una Partición de Intercambio (Swap) de Linux

En este paso, aprenderás sobre otro tipo especial de partición: el intercambio o swap de Linux. El espacio de intercambio es utilizado por el sistema operativo como memoria virtual cuando la memoria RAM física está llena. Permite al sistema mover 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 swap 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), podrías encontrar errores de "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 desmonta 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:

  1. Crear una nueva partición: Escribe n y presiona Enter.
  2. Elegir 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.
  3. Especificar sectores: Acepta el primer sector predeterminado. Para el tamaño, vamos a crear una partición de 256 MB. Escribe +256M y presiona Enter.
  4. Cambiar el tipo de partición: Este es el paso crucial. Escribe t para cambiar el tipo de una partición. Cuando se te pida el número de partición, ingresa 2. Cuando se te pida el código hexadecimal, ingresa 82, que corresponde a "Linux swap / Solaris".
  5. Imprimir y verificar: Escribe p para revisar los cambios. Deberías ver /dev/sdb2 con su tipo listado como Linux swap / Solaris.
  6. 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 "Dispositivo o recurso ocupado", 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 es accesible, debes formatearla para su uso 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 del 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 swap usando el comando swapon.

sudo swapon /dev/sdb2

Verifica el uso del intercambio nuevamente 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 desactivar una partición swap, usa el comando swapoff.

sudo swapoff /dev/sdb2

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

Nota de resolución de problemas: Si encuentras errores de "Dispositivo o recurso ocupado" durante este paso, generalmente significa:

  1. El dispositivo o una de sus particiones está montado actualmente.
  2. 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 proceder con las operaciones de partición.

Resumen

En esta práctica de laboratorio, aprendiste las habilidades esenciales para administrar 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. Tras 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, la verificación de su estado y su desmontaje. 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 administración de un espacio de intercambio (swap) dedicado. Esto implicó usar fdisk nuevamente para crear una partición y cambiar su tipo a "Linux swap". Luego preparaste esta partición como área de intercambio con el comando mkswap y la activaste usando swapon. Para que el espacio de intercambio fuera persistente tras los reinicios, también agregaste la entrada correspondiente al archivo /etc/fstab.