Introducción
En este laboratorio, obtendrás experiencia práctica en la gestión de sistemas de archivos Linux en un sistema Red Hat Enterprise Linux (RHEL). Aprenderás a identificar sistemas de archivos y dispositivos de bloque, examinar el uso del disco mediante df y du, y practicar el montaje y desmontaje manual de sistemas de archivos.
Además, este laboratorio te guiará para localizar archivos de manera eficiente utilizando comandos como locate y find, lo que te permitirá buscar archivos basándote en diversos criterios como nombre, propietario, permisos, tamaño, tiempo y tipo de archivo.
Identificar sistemas de archivos y dispositivos de bloque
En este paso, aprenderás a identificar sistemas de archivos y dispositivos de bloque en un sistema Red Hat Enterprise Linux. Comprender cómo se organiza el almacenamiento es fundamental para la administración del sistema. Exploraremos varios comandos para listar y examinar los dispositivos de bloque y sus sistemas de archivos asociados.
Primero, comprendamos algunos conceptos clave:
- Dispositivo de bloque (Block Device): Es un archivo que proporciona acceso de bajo nivel a dispositivos de almacenamiento. Ejemplos incluyen discos duros, SSD y unidades USB. En Linux, estos se encuentran generalmente en el directorio
/dev. - Partición: Es una división lógica de un dispositivo de almacenamiento físico. Un solo disco duro puede tener múltiples particiones, cada una formateada con un sistema de archivos diferente o utilizada para propósitos distintos.
- Sistema de archivos (File System): Es un método y estructura de datos que utiliza un sistema operativo para controlar cómo se almacenan y recuperan los datos. Organiza la información en archivos y directorios. Los sistemas de archivos comunes en Linux incluyen XFS y ext4.
- Punto de montaje (Mount Point): Es un directorio vacío en la jerarquía del sistema de archivos donde se conecta o "monta" un sistema de archivos para hacer accesible su contenido.
Comencemos listando los dispositivos de bloque disponibles en tu sistema usando el comando lsblk. Este comando proporciona una vista general en forma de árbol de todos los dispositivos de bloque y sus particiones.
lsblk
Deberías ver una salida similar a esta. Tu máquina virtual puede usar nombres como vda y vdb, o nombres NVMe como nvme0n1 y nvme1n1:
NAME MAJ:MIN RM SIZE RO TYPE MOUNTPOINTS
vda 253:0 0 40G 0 disk
├─vda1 253:1 0 1M 0 part
├─vda2 253:2 0 100M 0 part /boot/efi
└─vda3 253:3 0 39.9G 0 part /
vdb 253:16 0 40G 0 disk
En la salida:
NAME: El nombre del dispositivo de bloque (por ejemplo,vda,vdb,nvme0n1onvme1n1) o partición (por ejemplo,vda1,vda2onvme0n1p2).MAJ:MIN: Números mayor y menor del dispositivo.RM: Dispositivo extraíble (1 si es extraíble, 0 si no).SIZE: El tamaño del dispositivo o partición.RO: Solo lectura (1 si es solo lectura, 0 si no).TYPE: Tipo de dispositivo (ej.disk,partpara partición).MOUNTPOINTS: Dónde está montado actualmente el dispositivo o partición.
A continuación, examinemos los sistemas de archivos y su uso con el comando df. El comando df informa sobre el uso del espacio en disco de los sistemas de archivos.
df
La salida mostrará varios sistemas de archivos, su tamaño total, espacio utilizado, espacio disponible y puntos de montaje:
Filesystem 1K-blocks Used Available Use% Mounted on
devtmpfs 4096 0 4096 0% /dev
tmpfs 1822216 0 1822216 0% /dev/shm
tmpfs 728888 616 728272 1% /run
efivarfs 256 9 243 4% /sys/firmware/efi/efivars
/dev/vda3 41773036 3628732 38144304 9% /
/dev/vda2 102156 7198 94958 8% /boot/efi
tmpfs 364440 0 364440 0% /run/user/1000
Para hacer la salida más legible, especialmente para los tamaños, puedes usar la opción -h para un formato legible por humanos (ej. M para MiB, G para GiB).
df -h
Verás los tamaños en un formato más comprensible:
Filesystem Size Used Avail Use% Mounted on
devtmpfs 4.0M 0 4.0M 0% /dev
tmpfs 1.8G 0 1.8G 0% /dev/shm
tmpfs 712M 616K 712M 1% /run
efivarfs 256K 8.5K 243K 4% /sys/firmware/efi/efivars
/dev/vda3 40G 3.5G 37G 9% /
/dev/vda2 100M 7.1M 93M 8% /boot/efi
tmpfs 356M 0 356M 0% /run/user/1000
Finalmente, usemos el comando lsblk -fp para listar la ruta completa de los dispositivos, sus UUID (Identificadores Únicos Universales) y los tipos de sistema de archivos. Los UUID son identificadores estables que permanecen iguales incluso si cambian los nombres de los dispositivos, lo que los hace útiles para un montaje consistente.
lsblk -fp
La salida incluirá los UUID y los tipos de sistema de archivos:
NAME FSTYPE FSVER LABEL UUID FSAVAIL FSUSE% MOUNTPOINTS
/dev/vda
├─/dev/vda1
├─/dev/vda2 vfat FAT16 E52E-0564 92.7M 7% /boot/efi
└─/dev/vda3 xfs root 4c234c8b-4f67-4d65-abb5-06753b1ec236 36.4G 9% /
/dev/vdb
Observa la columna UUID, que proporciona un identificador único para cada sistema de archivos. Esto es crucial para montar sistemas de archivos de manera fiable, especialmente en archivos de configuración como /etc/fstab.
Antes de pasar al siguiente paso, guarda un breve informe en tu directorio de proyecto para que puedas revisar la información del dispositivo de bloque y del sistema de archivos más tarde.
{
lsblk
echo
df -h
echo
lsblk -fp
} > ~/project/filesystem_overview.txt
Puedes confirmar que el informe se creó con:
cat ~/project/filesystem_overview.txt
Examinar el uso del sistema de archivos con df y du
En este paso, profundizaremos en el examen del uso del sistema de archivos utilizando los comandos df y du. Mientras que df proporciona una visión general del uso del espacio en disco para los sistemas de archivos montados, du (disk usage) se utiliza para estimar el uso de espacio de archivos para archivos o directorios específicos. Comprender la diferencia y cuándo usar cada comando es crucial para una gestión eficaz del espacio en disco.
Comencemos revisando el comando df con su opción legible por humanos. Este comando es excelente para obtener un resumen rápido de cuánto espacio se utiliza y está disponible en todos los sistemas de archivos montados.
df -h
La salida mostrará el uso del disco en un formato fácil de leer (ej. G para gigabytes, M para megabytes):
Filesystem Size Used Avail Use% Mounted on
devtmpfs 892M 0 892M 0% /dev
tmpfs 915M 0 915M 0% /dev/shm
tmpfs 915M 17M 899M 2% /run
tmpfs 915M 0 915M 0% /sys/fs/cgroup
/dev/vda4 8.0G 1.4G 6.7G 17% /
/dev/vda3 1014M 166M 849M 17% /boot
tmpfs 183M 0 183M 0% /run/user/1000
Ahora, exploremos el comando du. A diferencia de df, du calcula el espacio en disco utilizado por archivos y directorios dentro de una ruta especificada. Esto es particularmente útil cuando quieres averiguar qué directorios o archivos están consumiendo más espacio.
Para ver el uso del disco de tu directorio actual (~/project), usa du sin argumentos. Esto listará el tamaño de cada archivo y subdirectorio dentro de ~/project.
du
La salida puede ser extensa, mostrando los tamaños en kilobytes por defecto:
4 ./.config/xfce4/xfconf/xfce-perchannel-xml
8 ./.config/xfce4/xfconf
12 ./.config/xfce4
16 ./.config
4 ./.local/share/nano
8 ./.local/share
12 ./.local
28 .
Para hacer la salida más legible, similar a df -h, puedes usar la opción -h con du.
du -h
Esto mostrará los tamaños en unidades legibles por humanos:
4.0K ./.config/xfce4/xfconf/xfce-perchannel-xml
8.0K ./.config/xfce4/xfconf
12K ./.config/xfce4
16K ./.config
4.0K ./.local/share/nano
8.0K ./.local/share
12K ./.local
28K .
A menudo, te interesa el tamaño total de un directorio en lugar del tamaño de cada archivo y subdirectorio individual. Para esto, puedes usar la opción -s (resumen) junto con -h. Revisemos el tamaño total de tu directorio personal (~).
du -sh ~
Este comando mostrará el tamaño total de tu directorio personal:
48K /home/labex
Creemos algunos archivos para ver cómo du reporta sus tamaños. Crearemos un directorio llamado test_data y luego crearemos algunos archivos dentro de él.
Primero, crea el directorio:
mkdir ~/project/test_data
Ahora, navega al directorio test_data:
cd ~/project/test_data
A continuación, crea algunos archivos con contenido. Usaremos el comando head para generar archivos de tamaños específicos.
head -c 1K < /dev/urandom > file1.txt
head -c 5K < /dev/urandom > file2.txt
head -c 10K < /dev/urandom > file3.txt
Ahora, usa du -h para ver los tamaños de estos nuevos archivos y del directorio test_data.
du -h
Deberías ver una salida similar a esta:
1.0K ./file1.txt
5.0K ./file2.txt
10K ./file3.txt
24K .
La última línea (24K .) muestra el tamaño total del directorio actual (., que es ~/project/test_data).
Finalmente, volvamos a tu directorio ~/project y verifica el tamaño total de test_data usando du -sh.
cd ~/project
du -sh test_data
Esto mostrará el tamaño resumido del directorio test_data:
24K test_data
Esto demuestra cómo se puede usar du para identificar el consumo de espacio en disco dentro de directorios específicos, ayudándote a gestionar el almacenamiento de manera efectiva.
Montar y desmontar sistemas de archivos manualmente
En este paso, aprenderás a montar y desmontar sistemas de archivos manualmente. Montar un sistema de archivos hace que su contenido sea accesible a través de un directorio específico (punto de montaje) en la jerarquía del sistema de archivos. Desmontar separa el sistema de archivos de su punto de montaje, haciendo que su contenido sea inaccesible hasta que se monte de nuevo. Esta es una habilidad crítica para gestionar medios extraíbles, almacenamiento temporal o nuevas particiones de disco.
Para este ejercicio, usaremos el disco adicional no montado que está disponible en tu entorno de máquina virtual de LabEx. Dependiendo de la máquina virtual, ese disco podría llamarse /dev/vdb, /dev/nvme1n1 o algo similar, por lo que lo detectaremos en lugar de codificar un nombre de dispositivo.
Primero, identifiquemos el disco raíz y el disco adicional que formatearás y montarás.
ROOT_PARTITION=$(findmnt -n -o SOURCE /)
ROOT_DISK="/dev/$(lsblk -no PKNAME \"$ROOT_PARTITION\")"
DATA_DISK=$(lsblk -dnpo NAME,TYPE | awk '$2 == "disk" {print $1}' | grep -vx "$ROOT_DISK" | head -n 1)
echo "$DATA_DISK"
Este comando debería imprimir la ruta al disco adicional, como /dev/vdb o /dev/nvme1n1.
/dev/nvme1n1
Antes de que puedas montar un sistema de archivos, necesitas un punto de montaje, que es un directorio vacío. Es una práctica común usar /mnt para montajes temporales o crear un subdirectorio dentro de él. Creemos un nuevo directorio llamado mydata dentro de tu directorio ~/project para que sirva como nuestro punto de montaje.
mkdir ~/project/mydata
Ahora, necesitamos formatear el disco adicional almacenado en $DATA_DISK con un sistema de archivos. Usaremos el sistema de archivos XFS, que es el predeterminado para Red Hat Enterprise Linux. Ten cuidado con este comando, ya que borrará todos los datos en el dispositivo especificado.
sudo mkfs.xfs "$DATA_DISK"
Verás una salida indicando la creación del sistema de archivos XFS. El nombre del dispositivo en la salida coincidirá con tu máquina virtual:
meta-data=/dev/nvme1n1 isize=512 agcount=4, agsize=2621440 blks
= sectsz=512 attr=2, projid32bit=1
= crc=1 finobt=1, sparse=1, rmapbt=0
= reflink=1 bigtime=1 inobtcount=1 nrext64=0
data = bsize=4096 blocks=10485760, imaxpct=25
= sunit=0 swidth=0 blks
naming =version 2 bsize=4096 ascii-ci=0, ftype=1
log =internal log bsize=4096 blocks=16384, version=2
= sectsz=512 sunit=0 blks, lazy-count=1
realtime =none extsz=4096 blocks=0, rtextents=0
Ahora que $DATA_DISK tiene un sistema de archivos XFS, puedes montarlo en tu punto de montaje ~/project/mydata. El comando mount requiere privilegios de sudo.
sudo mount "$DATA_DISK" ~/project/mydata
Para verificar que el sistema de archivos se ha montado correctamente, usa el comando df -h de nuevo. Deberías ver tu disco detectado listado con /home/labex/project/mydata como su punto de montaje.
df -h
Busca tu disco detectado en la salida:
Filesystem Size Used Avail Use% Mounted on
...
/dev/nvme1n1 40G 318M 40G 1% /home/labex/project/mydata
Ahora, puedes crear archivos y directorios dentro de ~/project/mydata, y se almacenarán en el disco en $DATA_DISK. Creemos un archivo de prueba:
sudo touch ~/project/mydata/testfile.txt
Puedes listar el contenido de ~/project/mydata para confirmar la creación del archivo:
ls -l ~/project/mydata
Deberías ver testfile.txt listado:
total 0
-rw-r--r--. 1 root root 0 Jun 16 11:09 testfile.txt
Cuando termines de usar un sistema de archivos montado, es importante desmontarlo para evitar la corrupción de datos, especialmente antes de retirar un dispositivo físico. Usa el comando umount para desmontar el sistema de archivos.
sudo umount ~/project/mydata
Si el comando de desmontaje falla con un error de "target is busy" (objetivo ocupado), significa que algún proceso todavía está accediendo al punto de montaje. Esto sucede a menudo si tu directorio de trabajo actual está dentro del sistema de archivos montado. Para resolver esto, cambia tu directorio actual a una ubicación fuera del punto de montaje, por ejemplo, tu directorio personal (~).
cd ~
Luego, intenta desmontar de nuevo:
sudo umount ~/project/mydata
Después de desmontar, verifica que tu disco detectado ya no esté montado comprobando df -h de nuevo.
df -h
Ya no deberías ver tu disco detectado montado en /home/labex/project/mydata.
Filesystem Size Used Avail Use% Mounted on
...
## Tu disco adicional ya no debería aparecer aquí.
Esto completa el proceso de montar y desmontar manualmente un sistema de archivos.
Localizar archivos por nombre con locate y find
En este paso, aprenderás a localizar archivos en tu sistema usando dos comandos potentes: locate y find. Ambos comandos te ayudan a buscar archivos, pero operan de manera diferente y son adecuados para diferentes escenarios.
Usar el comando locate
El comando locate es muy rápido porque busca en una base de datos preconstruida de nombres de archivos y rutas. Sin embargo, esto significa que podría no encontrar archivos que fueron creados o eliminados desde la última actualización de la base de datos. La base de datos se actualiza normalmente a diario mediante un trabajo cron, pero puedes forzar una actualización.
En esta imagen, el comando locate ya está disponible. Confirma que el comando existe antes de actualizar su base de datos.
command -v locate
Deberías ver una salida similar a esta:
/usr/bin/locate
Después de la instalación, necesitas actualizar la base de datos de locate. Este comando requiere privilegios de sudo.
sudo updatedb
Este comando se ejecutará silenciosamente y puede tardar unos momentos dependiendo del tamaño de tu sistema de archivos.
Ahora, busquemos un archivo de sistema común, como passwd.
locate passwd
Verás una lista de rutas que contienen "passwd":
/etc/passwd
/etc/passwd-
/etc/pam.d/passwd
/usr/share/man/man1/passwd.1.gz
/usr/share/man/man5/passwd.5.gz
...output omitted...
Para realizar una búsqueda que no distinga entre mayúsculas y minúsculas, usa la opción -i. Busquemos archivos que contengan "messages" sin preocuparnos por las mayúsculas.
locate -i messages
Verás resultados como:
/usr/share/locale/zza/LC_MESSAGES
/usr/share/makedumpfile/eppic_scripts/ap_messages_3_10_to_4_8.c
/usr/share/vim/vim82/ftplugin/msmessages.vim
...output omitted...
También puedes limitar el número de resultados usando la opción -n. Busquemos las primeras 5 ocurrencias de "passwd".
locate -n 5 passwd
Esto mostrará solo las primeras 5 coincidencias:
/etc/passwd
/etc/passwd-
/etc/pam.d/passwd
/usr/share/man/man1/passwd.1.gz
/usr/share/man/man5/passwd.5.gz
Usar el comando find
El comando find busca en el sistema de archivos en tiempo real, lo que lo hace más lento que locate pero asegura que encuentre todos los archivos que coinciden con tus criterios, incluidos los creados muy recientemente. También ofrece opciones de búsqueda mucho más potentes.
La sintaxis básica para find es find [ruta] [expresión]. Si no se especifica ninguna ruta, busca en el directorio actual.
Busquemos el archivo sshd_config comenzando desde el directorio raíz (/).
find / -name sshd_config
Deberías ver la ruta al archivo de configuración:
/etc/ssh/sshd_config
Al buscar nombres parciales o usar comodines, es importante entrecomillar el patrón del nombre de archivo para evitar que el shell lo expanda prematuramente. Busquemos todos los archivos que terminan en .txt en tu directorio ~/project.
find ~/project -name '*.txt'
Si creaste file1.txt, file2.txt y file3.txt en el paso anterior, deberías verlos listados:
/home/labex/project/test_data/file1.txt
/home/labex/project/test_data/file2.txt
/home/labex/project/test_data/file3.txt
Para realizar una búsqueda que no distinga entre mayúsculas y minúsculas con find, usa la opción -iname. Busquemos archivos que contengan "README" (sin distinguir mayúsculas/minúsculas) en el directorio /usr/share/doc.
find /usr/share/doc -iname '*readme*'
Verás muchos resultados, por ejemplo:
/usr/share/doc/libselinux/README
/usr/share/doc/libsepol/README
/usr/share/doc/libsemanage/README
...output omitted...
El comando find es muy versátil y se puede combinar con otros criterios, que explorarás en los siguientes pasos.
Antes de continuar, guarda los resultados clave de locate y find para que puedas compararlos más tarde.
{
locate -n 5 passwd
echo "---"
find ~/project -name '*.txt'
} > ~/project/search-results.txt
Puedes revisar los resultados guardados con:
cat ~/project/search-results.txt
Encontrar archivos por propietario, permisos, tamaño y tiempo
En este paso, aprenderás a usar el potente comando find para localizar archivos basándote en varios criterios más allá de su nombre. Esto incluye buscar por propietario, permisos, tamaño y tiempo de modificación. Estas capacidades de búsqueda avanzada son esenciales para tareas de administración del sistema como auditoría, limpieza y resolución de problemas.
Encontrar archivos por propietario
Puedes buscar archivos propiedad de un usuario o grupo específico usando las opciones -user y -group, respectivamente. Puedes especificar el nombre del usuario/grupo o su ID numérico.
Busquemos todos los archivos en tu directorio personal (~) que sean propiedad del usuario labex.
find ~ -user labex
Esto listará muchos archivos, incluidos tus archivos de configuración:
/home/labex
/home/labex/.bash_logout
/home/labex/.bash_profile
/home/labex/.bashrc
/home/labex/.config
/home/labex/.config/xfce4
/home/labex/.config/xfce4/xfconf
/home/labex/.config/xfce4/xfconf/xfce-perchannel-xml
/home/labex/.local
/home/labex/.local/share
/home/labex/.local/share/nano
/home/labex/project
/home/labex/project/test_data
/home/labex/project/test_data/file1.txt
/home/labex/project/test_data/file2.txt
/home/labex/project/test_data/file3.txt
...output omitted...
De manera similar, para encontrar archivos propiedad del grupo labex:
find ~ -group labex
La salida será similar, ya que labex suele ser el grupo principal para el usuario labex.
También puedes buscar por ID de usuario (UID) o ID de grupo (GID). El usuario labex suele tener un UID y GID de 1000.
find ~ -uid 1000
find ~ -gid 1000
Encontrar archivos por permisos
La opción -perm del comando find te permite buscar archivos con permisos específicos. Los permisos se pueden especificar en modo octal (ej. 755) o simbólico (ej. u=rwx,g=rx,o=rx).
Creemos un archivo de prueba en tu directorio ~/project con permisos específicos.
touch ~/project/permission_test.txt
chmod 644 ~/project/permission_test.txt
Ahora, busquemos archivos en ~/project que tengan exactamente permisos 644.
find ~/project -perm 644
Deberías ver permission_test.txt listado:
/home/labex/project/permission_test.txt
También puedes usar una / o - inicial con los permisos octales:
/: Coincide si cualquiera de los bits de permiso especificados está establecido.-: Coincide si todos los bits de permiso especificados están establecidos.
Busquemos archivos en ~/project donde otros tengan al menos permiso de lectura (o=r o 004).
find ~/project -perm -004
Esto listará permission_test.txt y otros archivos que otorgan acceso de lectura a otros.
/home/labex/project/permission_test.txt
...output omitted...
Encontrar archivos por tamaño
La opción -size te permite buscar archivos basándote en su tamaño. Puedes especificar el tamaño con unidades (ej. k para kilobytes, M para megabytes, G para gigabytes). También puedes usar + para "mayor que" y - para "menor que".
Busquemos archivos en tu directorio ~/project/test_data que tengan exactamente 1 kilobyte de tamaño.
find ~/project/test_data -size 1k
Deberías ver file1.txt:
/home/labex/project/test_data/file1.txt
Ahora, busca archivos mayores de 5 kilobytes.
find ~/project/test_data -size +5k
Esto debería listar file3.txt:
/home/labex/project/test_data/file3.txt
Y archivos menores de 10 kilobytes.
find ~/project/test_data -size -10k
Esto debería listar file1.txt y file2.txt:
/home/labex/project/test_data/file1.txt
/home/labex/project/test_data/file2.txt
Encontrar archivos por tiempo de modificación
Puedes buscar archivos basándote en su tiempo de modificación usando opciones como -mmin (modificado hace minutos) o -mtime (modificado hace días).
Busquemos archivos en tu directorio ~/project que fueron modificados en los últimos 60 minutos.
find ~/project -mmin -60
Esto probablemente incluirá permission_test.txt y los archivos en test_data si los creaste recientemente:
/home/labex/project
/home/labex/project/permission_test.txt
/home/labex/project/test_data
/home/labex/project/test_data/file1.txt
/home/labex/project/test_data/file2.txt
/home/labex/project/test_data/file3.txt
Para encontrar archivos modificados hace más de 1 día (24 horas), puedes usar +1 con -mtime.
find ~/project -mtime +1
Este comando podría no devolver ningún archivo si todos tus archivos de ~/project fueron creados o modificados recientemente.
Estas opciones se pueden combinar para crear consultas de búsqueda muy específicas, permitiéndote gestionar archivos en tu sistema de manera eficiente.
Guarda dos de tus resultados de búsqueda para que la siguiente verificación pueda confirmar que se encontraron los archivos correctos.
find ~/project -perm 644 > ~/project/find-perm-results.txt
find ~/project/test_data -size +5k > ~/project/find-size-results.txt
Buscar archivos según el tipo de archivo
En este paso final, aprenderás a usar el comando find para buscar archivos según su tipo. Esto es particularmente útil cuando necesitas localizar todos los directorios, archivos regulares, enlaces simbólicos o archivos de dispositivo dentro de una ruta específica.
El comando find usa la opción -type seguida de un solo carácter para especificar el tipo de archivo. Aquí hay algunos tipos de archivo comunes que puedes buscar:
f: Archivo regulard: Directoriol: Enlace simbólico (symlink)b: Dispositivo de bloquec: Dispositivo de caracteresp: Tubería con nombre (FIFO)s: Socket
Comencemos buscando todos los directorios dentro de tu directorio ~/project.
find ~/project -type d
Deberías ver una salida similar a esta, listando todos los directorios y subdirectorios:
/home/labex/project
/home/labex/project/test_data
A continuación, busquemos todos los archivos regulares dentro de tu directorio ~/project.
find ~/project -type f
Esto listará archivos como file1.txt, file2.txt y file3.txt que creaste anteriormente:
/home/labex/project/test_data/file1.txt
/home/labex/project/test_data/file2.txt
/home/labex/project/test_data/file3.txt
Ahora, creemos un enlace simbólico para demostrar la búsqueda de enlaces simbólicos. Crearemos un enlace simbólico a file1.txt en tu directorio ~/project.
ln -s ~/project/test_data/file1.txt ~/project/link_to_file1.txt
Verifica que el enlace simbólico se creó usando ls -l:
ls -l ~/project/link_to_file1.txt
Deberías ver una salida indicando que es un enlace simbólico:
lrwxrwxrwx. 1 labex labex 32 May 15 08:00 /home/labex/project/link_to_file1.txt -> /home/labex/project/test_data/file1.txt
Ahora, busca todos los enlaces simbólicos dentro de tu directorio ~/project.
find ~/project -type l
Deberías ver tu enlace simbólico recién creado:
/home/labex/project/link_to_file1.txt
Finalmente, busquemos dispositivos de bloque. Los dispositivos de bloque se encuentran normalmente en el directorio /dev.
find /dev -type b
Esto listará dispositivos de bloque como vda, vda1, vda2, etc.:
/dev/nvme0n1
/dev/nvme0n1p1
/dev/nvme0n1p2
/dev/nvme0n1p3
/dev/nvme1n1
Puedes combinar la opción -type con otras opciones de find que aprendiste en pasos anteriores. Por ejemplo, para encontrar todos los directorios en /etc que son propiedad del usuario root:
find /etc -type d -user root
Esto producirá una larga lista de directorios:
/etc
/etc/selinux
/etc/selinux/targeted
/etc/selinux/targeted/active
/etc/selinux/targeted/active/modules
...output omitted...
Guarda los resultados de la búsqueda de enlaces simbólicos antes de terminar el laboratorio.
find ~/project -type l > ~/project/find-type-results.txt
Esto concluye el laboratorio sobre el acceso a sistemas de archivos Linux y la localización de archivos. Has aprendido a identificar dispositivos, examinar el uso del disco, montar y desmontar manualmente sistemas de archivos, y usar locate y find con diversos criterios.
Resumen
En este laboratorio, obtuvimos experiencia práctica en la gestión de sistemas de archivos Linux en un sistema Red Hat Enterprise Linux. Comenzamos aprendiendo a identificar sistemas de archivos y dispositivos de bloque usando comandos como lsblk, comprendiendo conceptos centrales como dispositivos de bloque, particiones, sistemas de archivos y puntos de montaje. Posteriormente, exploramos cómo examinar el uso del sistema de archivos con df y du, distinguiendo entre sus funcionalidades para informar sobre el espacio en disco. El laboratorio también cubrió la habilidad esencial de montar y desmontar manualmente sistemas de archivos, demostrando cómo hacer accesible el contenido del sistema de archivos y luego separarlo.
Además, profundizamos en la localización eficiente de archivos utilizando diversos criterios. Aprendimos a encontrar archivos por nombre con locate y find, comprendiendo las diferencias y los casos de uso apropiados para cada uno. El laboratorio extendió esto enseñando cómo buscar archivos basándose en atributos de propietario, permisos, tamaño y tiempo, proporcionando herramientas poderosas para la administración del sistema y la resolución de problemas. Finalmente, practicamos la búsqueda de archivos basándonos en sus tipos de archivo específicos, completando una visión general integral de la gestión del sistema de archivos y las técnicas de localización de archivos.
