Introdução
Neste laboratório, você ganhará experiência prática no gerenciamento de sistemas de arquivos Linux em um sistema Red Hat Enterprise Linux (RHEL). Você aprenderá a identificar sistemas de arquivos e dispositivos de bloco, examinar o uso do disco usando df e du, e praticar a montagem e desmontagem manual de sistemas de arquivos.
Além disso, este laboratório o guiará na localização eficiente de arquivos usando comandos como locate e find, permitindo que você pesquise arquivos com base em vários critérios, como nome, proprietário, permissões, tamanho, tempo e tipo de arquivo.
Identificar Sistemas de Arquivos e Dispositivos de Bloco
Nesta etapa, você aprenderá como identificar sistemas de arquivos e dispositivos de bloco em um sistema Red Hat Enterprise Linux. Entender como o armazenamento é organizado é fundamental para a administração do sistema. Exploraremos vários comandos para listar e examinar dispositivos de bloco e seus sistemas de arquivos associados.
Primeiro, vamos entender alguns conceitos fundamentais:
- Dispositivo de Bloco (Block Device): Um dispositivo de bloco é um arquivo que fornece acesso de baixo nível a dispositivos de armazenamento. Exemplos incluem discos rígidos, SSDs e unidades USB. No Linux, eles geralmente são encontrados no diretório
/dev. - Partição: Uma partição é uma divisão lógica de um dispositivo de armazenamento físico. Um único disco rígido pode ter várias partições, cada uma formatada com um sistema de arquivos diferente ou usada para finalidades distintas.
- Sistema de Arquivos (File System): Um sistema de arquivos é um método e uma estrutura de dados que um sistema operacional usa para controlar como os dados são armazenados e recuperados. Ele organiza os dados em arquivos e diretórios. Sistemas de arquivos Linux comuns incluem XFS e ext4.
- Ponto de Montagem (Mount Point): Um ponto de montagem é um diretório vazio na hierarquia do sistema de arquivos onde um sistema de arquivos é anexado ou "montado" para tornar seu conteúdo acessível.
Vamos começar listando os dispositivos de bloco disponíveis em seu sistema usando o comando lsblk. Este comando fornece uma visão geral em árvore de todos os dispositivos de bloco e suas partições.
lsblk
Você verá uma saída semelhante a esta. Sua VM pode usar nomes como vda e vdb, ou pode usar nomes NVMe como nvme0n1 e 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
Na saída:
NAME: O nome do dispositivo de bloco (por exemplo,vda,vdb,nvme0n1ounvme1n1) ou partição (por exemplo,vda1,vda2ounvme0n1p2).MAJ:MIN: Números maior e menor do dispositivo.RM: Dispositivo removível (1 se removível, 0 se não).SIZE: O tamanho do dispositivo ou partição.RO: Somente leitura (1 se somente leitura, 0 se não).TYPE: Tipo do dispositivo (por exemplo,disk,partpara partição).MOUNTPOINTS: Onde o dispositivo ou partição está montado atualmente.
Em seguida, vamos examinar os sistemas de arquivos e seu uso com o comando df. O comando df relata o uso de espaço em disco do sistema de arquivos.
df
A saída mostrará vários sistemas de arquivos, seu tamanho total, espaço usado, espaço disponível e pontos de montagem:
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 tornar a saída mais legível, especialmente para tamanhos, você pode usar a opção -h para o formato legível por humanos (por exemplo, M para MiB, G para GiB).
df -h
Você verá os tamanhos em um formato mais compreensível:
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, vamos usar o comando lsblk -fp para listar o caminho completo dos dispositivos, seus UUIDs (Identificadores Únicos Universais) e tipos de sistema de arquivos. UUIDs são identificadores estáveis que permanecem os mesmos mesmo se os nomes dos dispositivos mudarem, tornando-os úteis para montagem consistente.
lsblk -fp
A saída incluirá UUIDs e tipos de sistema de arquivos:
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
Observe a coluna UUID, que fornece um identificador único para cada sistema de arquivos. Isso é crucial para montar sistemas de arquivos de forma confiável, especialmente em arquivos de configuração como /etc/fstab.
Antes de passar para a próxima etapa, salve um breve relatório em seu diretório de projeto para que você possa revisar as informações do dispositivo de bloco e do sistema de arquivos mais tarde.
{
lsblk
echo
df -h
echo
lsblk -fp
} > ~/project/filesystem_overview.txt
Você pode confirmar que o relatório foi criado com:
cat ~/project/filesystem_overview.txt
Examinar o Uso do Sistema de Arquivos com df e du
Nesta etapa, você se aprofundará no exame do uso do sistema de arquivos usando os comandos df e du. Enquanto o df fornece uma visão geral do uso do espaço em disco para sistemas de arquivos montados, o du (disk usage) é usado para estimar o uso de espaço em disco para arquivos ou diretórios específicos. Entender a diferença e quando usar cada comando é crucial para um gerenciamento eficaz do espaço em disco.
Vamos começar revisitando o comando df com sua opção legível por humanos. Este comando é excelente para obter um resumo rápido de quanto espaço é usado e está disponível em todos os sistemas de arquivos montados.
df -h
A saída mostrará o uso do disco em um formato fácil de ler (por exemplo, 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
Agora, vamos explorar o comando du. Ao contrário do df, o du calcula o espaço em disco usado por arquivos e diretórios dentro de um caminho especificado. Isso é particularmente útil quando você deseja descobrir quais diretórios ou arquivos estão consumindo mais espaço.
Para ver o uso do disco do seu diretório atual (~/project), use du sem nenhum argumento. Isso listará o tamanho de cada arquivo e subdiretório dentro de ~/project.
du
A saída pode ser extensa, mostrando tamanhos em kilobytes por padrão:
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 tornar a saída mais legível, semelhante ao df -h, você pode usar a opção -h com o du.
du -h
Isso exibirá os tamanhos em unidades legíveis 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 .
Muitas vezes, você está interessado no tamanho total de um diretório em vez do tamanho de cada arquivo e subdiretório individual. Para isso, você pode usar a opção -s (summary) junto com -h. Vamos verificar o tamanho total do seu diretório home (~).
du -sh ~
Este comando exibirá o tamanho total do seu diretório home:
48K /home/labex
Vamos criar alguns arquivos para ver como o du relata seus tamanhos. Criaremos um diretório chamado test_data e, em seguida, criaremos alguns arquivos dentro dele.
Primeiro, crie o diretório:
mkdir ~/project/test_data
Agora, navegue para o diretório test_data:
cd ~/project/test_data
Em seguida, crie alguns arquivos com algum conteúdo. Usaremos o comando head para gerar arquivos de tamanhos específicos.
head -c 1K < /dev/urandom > file1.txt
head -c 5K < /dev/urandom > file2.txt
head -c 10K < /dev/urandom > file3.txt
Agora, use du -h para ver os tamanhos desses novos arquivos e do diretório test_data.
du -h
Você deve ver uma saída semelhante a esta:
1.0K ./file1.txt
5.0K ./file2.txt
10K ./file3.txt
24K .
A última linha (24K .) mostra o tamanho total do diretório atual (., que é ~/project/test_data).
Finalmente, vamos voltar ao seu diretório ~/project e verificar o tamanho total de test_data usando du -sh.
cd ~/project
du -sh test_data
Isso mostrará o tamanho resumido do diretório test_data:
24K test_data
Isso demonstra como o du pode ser usado para identificar o consumo de espaço em disco dentro de diretórios específicos, ajudando você a gerenciar o armazenamento de forma eficaz.
Montar e Desmontar Sistemas de Arquivos Manualmente
Nesta etapa, você aprenderá como montar e desmontar sistemas de arquivos manualmente. Montar um sistema de arquivos torna seu conteúdo acessível através de um diretório específico (ponto de montagem) na hierarquia do sistema de arquivos. Desmontar desanexa o sistema de arquivos de seu ponto de montagem, tornando seu conteúdo inacessível até que seja montado novamente. Esta é uma habilidade crítica para gerenciar mídia removível, armazenamento temporário ou novas partições de disco.
Para este exercício, usaremos o disco extra não montado que está disponível em seu ambiente de VM LabEx. Dependendo da VM, esse disco pode ser chamado de /dev/vdb, /dev/nvme1n1 ou algo semelhante, então vamos detectá-lo em vez de codificar um nome de dispositivo.
Primeiro, vamos identificar o disco raiz e o disco extra que você formatará e montará.
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 deve imprimir o caminho para o disco extra, como /dev/vdb ou /dev/nvme1n1.
/dev/nvme1n1
Antes de montar um sistema de arquivos, você precisa de um ponto de montagem, que é um diretório vazio. É prática comum usar /mnt para montagens temporárias ou criar um subdiretório dentro dele. Vamos criar um novo diretório chamado mydata dentro do seu diretório ~/project para servir como nosso ponto de montagem.
mkdir ~/project/mydata
Agora, precisamos formatar o disco extra armazenado em $DATA_DISK com um sistema de arquivos. Usaremos o sistema de arquivos XFS, que é o padrão para o Red Hat Enterprise Linux. Tenha cuidado com este comando, pois ele apagará todos os dados no dispositivo especificado.
sudo mkfs.xfs "$DATA_DISK"
Você verá uma saída indicando a criação do sistema de arquivos XFS. O nome do dispositivo na saída corresponderá à sua VM:
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
Agora que $DATA_DISK possui um sistema de arquivos XFS, você pode montá-lo em seu ponto de montagem ~/project/mydata. O comando mount requer privilégios de sudo.
sudo mount "$DATA_DISK" ~/project/mydata
Para verificar se o sistema de arquivos foi montado com sucesso, use o comando df -h novamente. Você deve ver seu disco detectado listado com /home/labex/project/mydata como seu ponto de montagem.
df -h
Procure seu disco detectado na saída:
Filesystem Size Used Avail Use% Mounted on
...
/dev/nvme1n1 40G 318M 40G 1% /home/labex/project/mydata
Agora, você pode criar arquivos e diretórios dentro de ~/project/mydata, e eles serão armazenados no disco em $DATA_DISK. Vamos criar um arquivo de teste:
sudo touch ~/project/mydata/testfile.txt
Você pode listar o conteúdo de ~/project/mydata para confirmar a criação do arquivo:
ls -l ~/project/mydata
Você deve ver testfile.txt listado:
total 0
-rw-r--r--. 1 root root 0 Jun 16 11:09 testfile.txt
Quando terminar de usar um sistema de arquivos montado, é importante desmontá-lo para evitar corrupção de dados, especialmente antes de remover um dispositivo físico. Use o comando umount para desmontar o sistema de arquivos.
sudo umount ~/project/mydata
Se o comando de desmontagem falhar com um erro de "target is busy" (alvo ocupado), significa que algum processo ainda está acessando o ponto de montagem. Isso geralmente acontece se o seu diretório de trabalho atual estiver dentro do sistema de arquivos montado. Para resolver isso, altere seu diretório atual para um local fora do ponto de montagem, por exemplo, seu diretório home (~).
cd ~
Em seguida, tente desmontar novamente:
sudo umount ~/project/mydata
Após desmontar, verifique se seu disco detectado não está mais montado verificando df -h novamente.
df -h
Você não deve mais ver seu disco detectado montado em /home/labex/project/mydata.
Filesystem Size Used Avail Use% Mounted on
...
## Seu disco extra não deve mais estar listado aqui.
Isso conclui o processo de montagem e desmontagem manual de um sistema de arquivos.
Localizar Arquivos por Nome com locate e find
Nesta etapa, você aprenderá como localizar arquivos em seu sistema usando dois comandos poderosos: locate e find. Ambos os comandos ajudam você a pesquisar arquivos, mas operam de maneira diferente e são adequados para cenários diferentes.
Usando o comando locate
O comando locate é muito rápido porque pesquisa em um banco de dados pré-construído de nomes de arquivos e caminhos. No entanto, isso significa que ele pode não encontrar arquivos que foram criados ou excluídos desde a última atualização do banco de dados. O banco de dados é normalmente atualizado diariamente por um trabalho cron, mas você pode forçar uma atualização.
Nesta imagem, o comando locate já está disponível. Confirme se o comando existe antes de atualizar seu banco de dados.
command -v locate
Você deve ver uma saída semelhante a esta:
/usr/bin/locate
Após a instalação, você precisa atualizar o banco de dados do locate. Este comando requer privilégios de sudo.
sudo updatedb
Este comando será executado silenciosamente e pode levar alguns instantes, dependendo do tamanho do seu sistema de arquivos.
Agora, vamos pesquisar um arquivo de sistema comum, como passwd.
locate passwd
Você verá uma lista de caminhos contendo "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 uma pesquisa que não diferencia maiúsculas de minúsculas, use a opção -i. Vamos pesquisar arquivos contendo "messages" sem se preocupar com letras maiúsculas.
locate -i messages
Você verá 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...
Você também pode limitar o número de resultados usando a opção -n. Vamos encontrar as primeiras 5 ocorrências de "passwd".
locate -n 5 passwd
Isso mostrará apenas as primeiras 5 correspondências:
/etc/passwd
/etc/passwd-
/etc/pam.d/passwd
/usr/share/man/man1/passwd.1.gz
/usr/share/man/man5/passwd.5.gz
Usando o comando find
O comando find pesquisa o sistema de arquivos em tempo real, o que o torna mais lento que o locate, mas garante que ele encontre todos os arquivos que correspondem aos seus critérios, incluindo aqueles criados muito recentemente. Ele também oferece opções de pesquisa muito mais poderosas.
A sintaxe básica para find é find [caminho] [expressão]. Se nenhum caminho for especificado, ele pesquisa o diretório atual.
Vamos pesquisar o arquivo sshd_config começando pelo diretório raiz (/).
find / -name sshd_config
Você deve ver o caminho para o arquivo de configuração:
/etc/ssh/sshd_config
Ao pesquisar nomes parciais ou usar curingas, é importante colocar o padrão do nome do arquivo entre aspas para evitar que o shell o expanda prematuramente. Vamos encontrar todos os arquivos terminados em .txt em seu diretório ~/project.
find ~/project -name '*.txt'
Se você criou file1.txt, file2.txt e file3.txt na etapa anterior, você deve vê-los listados:
/home/labex/project/test_data/file1.txt
/home/labex/project/test_data/file2.txt
/home/labex/project/test_data/file3.txt
Para realizar uma pesquisa que não diferencia maiúsculas de minúsculas com find, use a opção -iname. Vamos pesquisar arquivos contendo "README" (sem diferenciar maiúsculas de minúsculas) no diretório /usr/share/doc.
find /usr/share/doc -iname '*readme*'
Você verá muitos resultados, por exemplo:
/usr/share/doc/libselinux/README
/usr/share/doc/libsepol/README
/usr/share/doc/libsemanage/README
...output omitted...
O comando find é muito versátil e pode ser combinado com outros critérios, que você explorará nas próximas etapas.
Antes de continuar, salve os principais resultados do locate e find para que você possa compará-los mais tarde.
{
locate -n 5 passwd
echo "---"
find ~/project -name '*.txt'
} > ~/project/search-results.txt
Você pode revisar os resultados salvos com:
cat ~/project/search-results.txt
Encontrar Arquivos por Proprietário, Permissões, Tamanho e Tempo
Nesta etapa, você aprenderá como usar o poderoso comando find para localizar arquivos com base em vários critérios além de apenas seu nome. Isso inclui pesquisar por proprietário, permissões, tamanho e tempo de modificação. Esses recursos de pesquisa avançados são essenciais para tarefas de administração de sistema, como auditoria, limpeza e solução de problemas.
Encontrar Arquivos por Proprietário
Você pode pesquisar arquivos pertencentes a um usuário ou grupo específico usando as opções -user e -group, respectivamente. Você pode especificar o nome do usuário/grupo ou seu ID numérico.
Vamos encontrar todos os arquivos em seu diretório home (~) que pertencem ao usuário labex.
find ~ -user labex
Isso listará muitos arquivos, incluindo seus arquivos de configuração:
/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...
Da mesma forma, para encontrar arquivos pertencentes ao grupo labex:
find ~ -group labex
A saída será semelhante, já que labex é normalmente o grupo principal para o usuário labex.
Você também pode pesquisar por ID de Usuário (UID) ou ID de Grupo (GID). O usuário labex normalmente tem um UID e GID de 1000.
find ~ -uid 1000
find ~ -gid 1000
Encontrar Arquivos por Permissões
A opção -perm do comando find permite que você pesquise arquivos com permissões específicas. As permissões podem ser especificadas em modo octal (por exemplo, 755) ou simbólico (por exemplo, u=rwx,g=rx,o=rx).
Vamos criar um arquivo de teste em seu diretório ~/project com permissões específicas.
touch ~/project/permission_test.txt
chmod 644 ~/project/permission_test.txt
Agora, vamos encontrar arquivos em ~/project que tenham exatamente permissões 644.
find ~/project -perm 644
Você deve ver permission_test.txt listado:
/home/labex/project/permission_test.txt
Você também pode usar uma barra / ou um hífen - antes das permissões octais:
/: Corresponde se qualquer dos bits de permissão especificados estiver definido.-: Corresponde se todos os bits de permissão especificados estiverem definidos.
Vamos encontrar arquivos em ~/project onde outros tenham pelo menos permissão de leitura (o=r ou 004).
find ~/project -perm -004
Isso listará permission_test.txt e outros arquivos que concedem acesso de leitura a outros.
/home/labex/project/permission_test.txt
...output omitted...
Encontrar Arquivos por Tamanho
A opção -size permite que você pesquise arquivos com base em seu tamanho. Você pode especificar o tamanho com unidades (por exemplo, k para kilobytes, M para megabytes, G para gigabytes). Você também pode usar + para "maior que" e - para "menor que".
Vamos encontrar arquivos em seu diretório ~/project/test_data que tenham exatamente 1 kilobyte de tamanho.
find ~/project/test_data -size 1k
Você deve ver file1.txt:
/home/labex/project/test_data/file1.txt
Agora, encontre arquivos maiores que 5 kilobytes.
find ~/project/test_data -size +5k
Isso deve listar file3.txt:
/home/labex/project/test_data/file3.txt
E arquivos menores que 10 kilobytes.
find ~/project/test_data -size -10k
Isso deve listar file1.txt e file2.txt:
/home/labex/project/test_data/file1.txt
/home/labex/project/test_data/file2.txt
Encontrar Arquivos por Tempo de Modificação
Você pode pesquisar arquivos com base em seu tempo de modificação usando opções como -mmin (modificado há minutos) ou -mtime (modificado há dias).
Vamos encontrar arquivos em seu diretório ~/project que foram modificados nos últimos 60 minutos.
find ~/project -mmin -60
Isso provavelmente incluirá permission_test.txt e os arquivos em test_data se você os criou recentemente:
/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 arquivos modificados há mais de 1 dia (24 horas), você pode usar +1 com -mtime.
find ~/project -mtime +1
Este comando pode não retornar nenhum arquivo se todos os seus arquivos em ~/project foram criados ou modificados recentemente.
Essas opções podem ser combinadas para criar consultas de pesquisa muito específicas, permitindo que você gerencie arquivos em seu sistema de forma eficiente.
Salve dois de seus resultados de pesquisa para que a próxima verificação possa confirmar se os arquivos corretos foram encontrados.
find ~/project -perm 644 > ~/project/find-perm-results.txt
find ~/project/test_data -size +5k > ~/project/find-size-results.txt
Pesquisar Arquivos com Base no Tipo de Arquivo
Nesta etapa final, você aprenderá como usar o comando find para pesquisar arquivos com base em seu tipo. Isso é particularmente útil quando você precisa localizar todos os diretórios, arquivos regulares, links simbólicos ou arquivos de dispositivo dentro de um caminho específico.
O comando find usa a opção -type seguida por um único caractere para especificar o tipo de arquivo. Aqui estão alguns tipos de arquivo comuns que você pode pesquisar:
f: Arquivo regulard: Diretóriol: Link simbólico (symlink)b: Dispositivo de blococ: Dispositivo de caracterep: Pipe nomeado (FIFO)s: Socket
Vamos começar pesquisando todos os diretórios dentro do seu diretório ~/project.
find ~/project -type d
Você deve ver uma saída semelhante a esta, listando todos os diretórios e subdiretórios:
/home/labex/project
/home/labex/project/test_data
Em seguida, vamos pesquisar todos os arquivos regulares dentro do seu diretório ~/project.
find ~/project -type f
Isso listará arquivos como file1.txt, file2.txt e file3.txt que você criou anteriormente:
/home/labex/project/test_data/file1.txt
/home/labex/project/test_data/file2.txt
/home/labex/project/test_data/file3.txt
Agora, vamos criar um link simbólico para demonstrar a pesquisa de links simbólicos. Criaremos um link simbólico para file1.txt em seu diretório ~/project.
ln -s ~/project/test_data/file1.txt ~/project/link_to_file1.txt
Verifique se o link simbólico foi criado usando ls -l:
ls -l ~/project/link_to_file1.txt
Você deve ver uma saída indicando que é um link 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
Agora, pesquise todos os links simbólicos dentro do seu diretório ~/project.
find ~/project -type l
Você deve ver seu link simbólico recém-criado:
/home/labex/project/link_to_file1.txt
Finalmente, vamos pesquisar dispositivos de bloco. Dispositivos de bloco são normalmente encontrados no diretório /dev.
find /dev -type b
Isso listará dispositivos de bloco como vda, vda1, vda2, etc.:
/dev/nvme0n1
/dev/nvme0n1p1
/dev/nvme0n1p2
/dev/nvme0n1p3
/dev/nvme1n1
Você pode combinar a opção -type com outras opções de find que você aprendeu nas etapas anteriores. Por exemplo, para encontrar todos os diretórios em /etc que pertencem ao usuário root:
find /etc -type d -user root
Isso produzirá uma longa lista de diretórios:
/etc
/etc/selinux
/etc/selinux/targeted
/etc/selinux/targeted/active
/etc/selinux/targeted/active/modules
...output omitted...
Salve os resultados da pesquisa de link simbólico antes de terminar o laboratório.
find ~/project -type l > ~/project/find-type-results.txt
Isso conclui o laboratório sobre acesso a sistemas de arquivos Linux e localização de arquivos. Você aprendeu como identificar dispositivos, examinar o uso do disco, montar e desmontar sistemas de arquivos manualmente e usar locate e find com vários critérios.
Resumo
Neste laboratório, ganhamos experiência prática no gerenciamento de sistemas de arquivos Linux em um sistema Red Hat Enterprise Linux. Começamos aprendendo a identificar sistemas de arquivos e dispositivos de bloco usando comandos como lsblk, entendendo conceitos fundamentais como dispositivos de bloco, partições, sistemas de arquivos e pontos de montagem. Posteriormente, exploramos como examinar o uso do sistema de arquivos com df e du, distinguindo entre suas funcionalidades para relatar o espaço em disco. O laboratório também cobriu a habilidade essencial de montar e desmontar sistemas de arquivos manualmente, demonstrando como tornar o conteúdo do sistema de arquivos acessível e, em seguida, desanexá-lo.
Além disso, nos aprofundamos na localização eficiente de arquivos usando vários critérios. Aprendemos a encontrar arquivos por nome com locate e find, entendendo as diferenças e os casos de uso apropriados para cada um. O laboratório estendeu isso ensinando como pesquisar arquivos com base em atributos de proprietário, permissões, tamanho e tempo, fornecendo ferramentas poderosas para administração de sistema e solução de problemas. Finalmente, praticamos a pesquisa de arquivos com base em seus tipos de arquivo específicos, completando uma visão geral abrangente do gerenciamento de sistemas de arquivos e técnicas de localização de arquivos.
