cd ..
LINUX

Sobrevivendo no shell: do FHS ao diff, o Linux que você usa todo dia

#linux#cli#shell#fhs#sysadmin

Essas são minhas anotações de caderno enquanto estudo Linux a fundo — parte do curso Linux para Cloud Native, da LINUXtips, dentro da trilha do PICK 2026. Passei tudo a limpo aqui porque escrever é a melhor forma de fixar, e porque um dia isso vira referência rápida quando eu não lembrar de uma flag.

O post é longo de propósito: é o mapa completo do que se digita todo dia no terminal, do ls ao diff.

Primeiros passos

Duas referências que aparecem em todo lugar:

ls -lha /bin/ls   # lista o arquivo ls, que está dentro de /bin

E a leitura direta do kernel via /proc:

cd /proc
cat meminfo    # situação da memória RAM e swap
cat cpuinfo    # dados do processador

O cpuinfo mostra:

No Linux, tudo é um arquivo

Não é slogan, é literal:

É por isso que cat, grep e redirecionamento funcionam em praticamente tudo. Você não precisa de uma API para consultar a memória — só precisa ler um arquivo.

Árvore de diretórios e o FHS

No Linux existe uma única raiz: /. Tudo parte dela. Não importa quantos discos, partições ou dispositivos você tenha — todos serão montados em algum ponto dentro dessa árvore. Nada de C:, D:, E:.

Essa estrutura segue o padrão FHS (Filesystem Hierarchy Standard):

DiretórioO que é
/A raiz de tudo. O ponto de partida da árvore inteira
/homeDiretórios pessoais dos usuários. Se seu usuário é devops, será /home/devops. O atalho ~ representa o seu
/etcOnde fica a configuração do sistema: /etc/ssh/sshd_config, /etc/hostname, /etc/passwd
/varGuarda os dados que mudam com frequência, como em /var/log
/tmpDiretórios temporários
/usrContém programas, bibliotecas e documentação instalados pelo sistema
/bin e /sbinGuardam binários essenciais. Em distros modernas, normalmente apontam para diretórios dentro de /usr
/proc e /sysSão filesystems virtuais gerados em tempo real pelo kernel. Exibem informações de processos, memória, CPU, drivers e kernel
/devContém arquivos de dispositivo. Aqui também está o famoso /dev/null, o buraco negro do Linux
/mnt e /mediaPontos de montagem para dispositivos externos
/optSoftware de terceiros, instalado fora do gerenciador de pacotes

Detalhe do FHS: o fato de /bin e /sbin serem symlinks para dentro do /usr é resultado do usr-merge, adotado pela maioria das distros na última década. Faça ls -l /bin numa Fedora ou Ubuntu recente e você vai ver a seta.

Lendo o ls -l

ls -l   # mostra detalhes: permissões, dono, tamanho, data etc.

Uma linha típica:

drwxr-xr-x  4  root  root  4096  Abr 15 16:09  cache
│└┬┘└┬┘└┬┘  │   │     │     │       │            │
│ │  │  │   │   │     │     │       │            └─ nome
│ │  │  │   │   │     │     │       └────────────── data de modificação
│ │  │  │   │   │     │     └────────────────────── tamanho
│ │  │  │   │   │     └──────────────────────────── grupo
│ │  │  │   │   └────────────────────────────────── dono
│ │  │  │   └────────────────────────────────────── nº de links
│ │  │  └────────────────────────────────────────── permissões: outros
│ │  └───────────────────────────────────────────── permissões: grupo
│ └──────────────────────────────────────────────── permissões: dono
└────────────────────────────────────────────────── tipo

O primeiro caractere é o tipo:

Os nove seguintes são três blocos de rwx (read, write, execute) para dono, grupo e outros.

Manipulação de diretórios

ls — listar conteúdo

ComandoO que faz
ls -aLista todos os arquivos, inclusive os ocultos (os que começam com .)
ls -lTraz o detalhamento: permissões, dono, tamanho, data
ls -hDeixa o tamanho “humano”: 1K, 20M, 2G em vez de número gigante
ls -SClassifica pelo tamanho
ls -tOrdena por data de modificação
ls -FColoca um separador para identificar tipos (/ diretório, * executável, @ link)
ls -iMostra o número do inode
ls -RLista recursivamente
ls --color=autoUsa cores para diferenciar tipos de arquivo, mas só quando a saída está sendo exibida diretamente no terminal

A combinação que eu uso por reflexo:

ls -lha    # detalhado + ocultos + tamanho legível

O detalhe do --color=auto é mais interessante do que parece: se você fizer ls | grep algo, a saída não vai para o terminal, vai para o pipe — e o ls desliga as cores automaticamente. É por isso que os códigos de escape ANSI não vazam para o seu grep.

mkdir — criar diretórios

mkdir diretorio
mkdir -p gitopops/produtos/checkout   # cria todos os diretórios intermediários

O -p significa parents: ele cria os diretórios “pais” necessários no caminho. Mesmo que gitopops ainda não exista, ele cria primeiro e depois desce. Bônus: com -p o comando não falha se o diretório já existir — por isso ele aparece em tanto script de automação.

rmdir — remover diretórios vazios

rmdir pasta_vazia
rmdir -p Pasta2/Pasta2_2   # remove Pasta2_2 e tenta remover os pais, se ficarem vazios

O rmdir só remove diretório vazio. É uma proteção, não uma limitação.

cd, tree e touch

Manipulação de arquivos

cp — copiando

Sintaxe: cp [origem] [destino]

cp original.txt copia.txt               # copiando um arquivo
cp original.txt /tmp/                    # copiando um arquivo para um diretório
cp -r projetos/ /tmp/backup-projetos/    # copiando um diretório inteiro (obrigado usar -r)
FlagO que faz
-vVerbose: mostra na tela o que está sendo copiado
-r / -RRecursivo — obrigatório para diretórios
-aModo archive: preserva permissões, links e timestamps
-nCopia sem sobrescrever o que já existe
-uCopia só se a origem for mais nova que o destino
-sCria links simbólicos em vez de copiar

mv — movendo e renomeando

No Linux, mover e renomear são a mesma operação:

mv relatorio.txt /tmp/                                          # move para outro diretório
mv relatorio.txt relatorio-final.txt                            # renomeia
mv /tmp/relatorio.txt /home/devops/documentos/relatorio-v2.txt  # move e renomeia de uma vez

rm — removendo

rm arquivo-inutil.txt      # remove um arquivo
rm -r pasta-antiga/        # remove um diretório e tudo dentro dele
rm -rf pasta/              # força a remoção, sem confirmação

O -r é recursivo: ele entra em todas as subpastas e remove tudo — arquivos, subdiretórios, arquivos dentro dos subdiretórios.

O -f é força: não pede confirmação, não reclama se o arquivo não existir. Simplesmente apaga tudo silenciosamente.

⚠️ Cuidado extremo com rm -rf. Não pede confirmação, não tem lixeira e não tem desfazer. Antes de rodar com glob (*), troque o rm por ls e confira exatamente o que seria apagado.

Wildcards (curingas)

E se você quiser copiar todos os arquivos .log? Ou deletar todos os .tmp? Para isso existem os wildcards — padrões que o shell expande em nomes de arquivos antes de o comando sequer rodar.

* — qualquer coisa (zero ou mais caracteres)

ls /etc/*.conf              # todos os .conf em /etc
cp *.log /tmp/backup-logs/  # copia todos os .log do diretório atual
rm /tmp/*.tmp               # remove todos os .tmp de /tmp

O * é o mais usado. Ele substitui qualquer sequência de caracteres:

? — exatamente um caractere

ls arq_?.txt     # arq_1.txt, arq_a.txt — mas não arq_10.txt
ls arq_??.txt    # arq_10.txt, arq_ab.txt

[ ] — um caractere dentro de um conjunto ou intervalo

ls m[a-c]*       # arquivos que começam com m e cuja segunda letra vai de a até c
ls arq_[123].txt # arq_1.txt, arq_2.txt, arq_3.txt

which — onde está o binário?

which python3    # mostra o caminho do executável que o shell vai chamar

Empacotando e compactando

# Criar
tar -czf gitopops.tar.gz projetos/
#      │││
#      ││└─ file: nome do arquivo
#      │└── compactar (gzip)
#      └─── criar

# Ver o conteúdo sem extrair
tar -tf gitopops.tar.gz

# Extrair
tar -xzf backup-projeto.tar.gz

Regra mnemônica: create, extract, list — sempre acompanhados de -f (file). O -z é gzip; use -j para bzip2 e -J para xz.

É um ponteiro para um caminho de outro arquivo. Se o arquivo original for movido ou deletado, o link quebra.

# Criando um link simbólico
ln -s /etc/nginx/nginx.conf ~/nginx-config

# Verificando
ls -l ~/nginx-config
lrwxrwxrwx 1 devops devops 23 Feb 16 10:30 nginx-config -> /etc/nginx/nginx.conf

O l no início indica link simbólico. A seta mostra para onde ele aponta. Quando você fizer vim ~/nginx-config, estará editando o arquivo original em /etc/nginx/nginx.conf.

Aponta diretamente para os dados no disco (o inode), não para o caminho. Se o arquivo original for renomeado ou movido dentro do mesmo filesystem, o hard link continua funcionando. Mas ele não pode apontar para diretório nem cruzar filesystems diferentes.

# Criando um hard link
ln /etc/hostname ~/hostname-link

# Ambos apontam para o mesmo inode
ls -li /etc/hostname ~/hostname-link

O -i do ls mostra o número do inode — se for o mesmo nos dois, é o mesmo arquivo físico com dois nomes.

Visualizando e editando texto

cat — direto ao ponto

O cat (concatenate) despeja o conteúdo inteiro de um arquivo no terminal, de uma vez.

cat /etc/hostname

É perfeito para arquivos pequenos: um hostname, uma chave pública, um arquivo de configuração de poucas linhas. Mas se você rodar cat em um arquivo de 10.000 linhas, a saída vai inundar o terminal e você vai perder o controle do que está lendo. Para esse caso, use o less.

FlagO que faz
cat -nNumera todas as linhas
cat -bNumera só as linhas com texto
cat -EMostra $ no fim de cada linha
cat -TMostra TAB como ^I
cat -n /etc/ssh/sshd_config

Isso é ouro quando alguém diz “o erro está na linha 47” e você precisa ir direto ao ponto sem contar linhas na mão.

Os -E e -T salvam vidas quando você está caçando espaço em branco invisível ou fim de linha bizarro num arquivo de config.

cat com múltiplos arquivos: se você passar mais de um nome, ele concatena (daí o nome) a saída:

cat /etc/hostname /etc/os-release

Mostra o conteúdo dos dois arquivos, um depois do outro. Parece simples, mas é a base de muitas operações com redirecionamento.

Primos compactados:

ComandoO que faz
zcatLê arquivo .gz sem descompactar
bzcatLê arquivo .bz2 sem descompactar
xzcatLê arquivo .xz sem descompactar

Invertendo:

tac arquivo.txt      # mostra o arquivo de baixo para cima
tac -s "," arquivo   # inverte usando um separador específico

echo e redirecionamento

echo "Texto" > arquivo.txt     # sobrescreve
echo "Texto" >> arquivo.txt    # anexa ao final

less — navegação controlada

O less abre o arquivo em modo paginado, sem despejar tudo na tela de uma vez. Você navega com calma:

less /var/log/syslog

Os comandos de navegação dentro do less são essenciais:

TeclaO que faz
/termoInicia uma busca
nAvança para a próxima ocorrência
NVolta à ocorrência anterior
GPula para o final do arquivo
gVolta ao início
espaçoAvança uma página inteira
bRecua uma página inteira
qSai

O less é o paginador padrão de vários comandos. Quando você roda man ssh para ler o manual do SSH, o conteúdo abre no less. Os mesmos atalhos funcionam ali dentro. Saber navegar no less é saber navegar em toda a documentação do Linux.

Uma flag poderosa é o less +F, que transforma o less em modo follow — equivalente ao tail -f, mas com a vantagem de poder pausar com Ctrl+C, navegar pelo arquivo e depois retomar o fluxo com F.

less +F /var/log/syslog

more

Também pagina, mas sem a função de voltar. O less é estritamente superior. (Sim, a piada é essa mesma: less is more.)

head e tail — recortes cirúrgicos

O head mostra as primeiras linhas de um arquivo (10 por padrão):

head /etc/passwd

O tail mostra as últimas:

tail /var/log/syslog

Para especificar quantas linhas você quer ver, use a flag -n:

head -n 5 /etc/passwd
tail -n 50 /var/log/auth.log

O head é ótimo para visualizar rapidamente a estrutura de um arquivo de configuração sem carregar ele inteiro. Já o tail é indispensável para logs, porque a informação mais recente está sempre no final.

tail -f — o monitor de logs em tempo real

Esse é um dos comandos que mais vamos usar na carreira. O tail -f (follow) não apenas mostra as últimas linhas: ele fica aberto e mostra novas linhas conforme elas são escritas no arquivo.

tail -f /var/log/syslog

O terminal vira um monitor de logs ao vivo. Enquanto o tail -f estiver rodando, qualquer serviço que escreva no syslog aparece instantaneamente na tela. É assim que se investiga problema em tempo real: abre o log e observa o que está acontecendo enquanto você reproduz o erro.

Combinar com grep filtra apenas o que te interessa:

tail -f /var/log/auth.log | grep "Failed password"

Agora você vê apenas tentativas de login que falharam, em tempo real. Perfeito para detectar força bruta no SSH, por exemplo.

O | (pipe) pega a saída de um comando e joga como entrada para o próximo. Para sair do tail -f, aperte Ctrl+C.

wc — contando linhas, palavras e bytes

O wc (word count) é um comando simples que responde perguntas rápidas sobre o conteúdo de um arquivo:

wc /var/log/syslog

A saída mostra três números: total de linhas, total de palavras e total de bytes. Na maioria das vezes, você só quer a contagem de linhas:

wc -l /var/log/syslog

Isso responde a perguntas como “quantas linhas tem esse log?”, “esse arquivo de configuração é grande?”, “quantas entradas existem no /etc/passwd?” (cada linha = um usuário).

Parece trivial, mas é um dos comandos mais usados em scripts e pipelines:

grep -c "ERROR" app.log          # conta ocorrências direto
ps aux | grep nginx | wc -l      # quantos processos nginx estão rodando

diff — comparando arquivos

O diff compara dois arquivos e mostra exatamente o que mudou entre eles:

diff /etc/ssh/sshd_config /etc/ssh/sshd_config.bak

As linhas que começam com < existem apenas no primeiro arquivo. As que começam com > existem apenas no segundo.

Quando você faz backup de um arquivo antes de editá-lo (e sempre deve fazer), o diff mostra exatamente o que alteramos.

Uma versão mais visual é o diff -u (unified format), que mostra as diferenças com contexto, no mesmo formato que o Git usa:

diff -u original.conf modificado.conf

As linhas com - foram removidas e as com + foram adicionadas. Quem já usou git diff vai reconhecer o formato imediatamente — porque é literalmente o mesmo.

grep, sort e amigos

Data e hora

date                        # mostra a data
sudo date -s "..."          # configura a data
date -u                     # mostra o horário UTC
date +%d/%m/%Y              # muda o formato de exibição
date +%d-%m-%y

df — espaço em disco

ComandoO que faz
dfMostra o espaço livre em cada partição montada no sistema operacional
df -HFormato “humano”, usando base 1000
df -hFormato humano, usando base 1024
df -mMostra tudo em megabytes
df -lMostra apenas sistemas de arquivos locais
df -iMostra o uso de inodes do sistema de arquivos
df -TMostra o uso do disco incluindo o tipo do sistema de arquivos
df -ThFormato humano e tipo de FS — o mais útil no dia a dia

O que é inode?

Um inode é uma espécie de “ficha interna” que o Linux usa para controlar arquivos e diretórios. Cada arquivo usa 1 inode.

Por isso o df -i importa: ele mostra se o sistema ainda tem capacidade para criar novos arquivos e diretórios — não apenas se tem GB livres. Dá para ter 200 GB sobrando e mesmo assim receber No space left on device porque os inodes acabaram. É um clássico em servidor cheio de arquivos pequenos, tipo cache de sessão.

Gerenciamento e execução de processos

ps                  # mostra os processos rodando no terminal atual
ps -a               # todos os processos em execução em outros terminais do meu usuário
ps aux              # todos os processos do sistema, formato completo
ps aux | grep nginx # filtra por um processo específico

O /proc

O /proc é um sistema de arquivos virtual. Ele não é uma pasta comum no disco.

Ele mostra informações do kernel, processos, memória, CPU, rede, etc. É tipo um painel de diagnóstico do Linux — cada processo em execução tem um diretório /proc/<PID> com tudo sobre ele.

Ferramentas como ps e top não têm mágica nenhuma: elas apenas leem o /proc e formatam a saída.

Fechando

Nada aqui é exótico, e esse é exatamente o ponto: são os comandos que você digita cem vezes por dia sem pensar — até o dia em que precisa de uma flag específica e não lembra.

Se eu tivesse que escolher os cinco que mais mudaram meu dia a dia da lista acima, seriam: tail -f | grep (investigação em tempo real), less (navegação em qualquer documentação), diff -u (antes de qualquer mudança em produção), df -Th (o primeiro comando quando algo quebra) e ls -lha (puro reflexo).

Deixo essa página aberta como referência, e sugiro que você monte a sua.

Próximas anotações: permissões (chmod, chown, umask), gerenciamento de pacotes e systemd.

Referências

O que achou?

// continue lendo

LINUXAnatomia dos repositórios do APT: sources.list, componentes e PPAsLINUXDo .exe ao apt install: entendendo o gerenciamento de pacotes no LinuxLINUXACLs no Linux: controle de acesso além do dono, grupo e outros