Entendendo o Filesystem Linux
O filesystem Linux é a estrutura fundamental que organiza todos os arquivos e diretórios no sistema. Diferentemente do Windows, que possui unidades como C:, D:, o Linux utiliza uma estrutura hierárquica centralizada que começa na raiz (/) e se expande em árvore. Tudo no Linux é considerado um arquivo — diretórios, dispositivos, pipes e sockets. Essa filosofia unificada permite que você manipule praticamente qualquer recurso do sistema usando as mesmas ferramentas de manipulação de arquivos.
A estrutura básica do filesystem segue um padrão estabelecido pelo Filesystem Hierarchy Standard (FHS). O diretório / é a raiz absoluta, e a partir dele temos diretórios importantes como /home (onde ficam os arquivos dos usuários), /etc (configurações do sistema), /var (dados variáveis como logs), /bin (programas executáveis), /usr (programas e bibliotecas do usuário) e /root (home do usuário root). Compreender essa estrutura é essencial para navegar eficientemente e gerenciar permissões de forma segura.
Estrutura de Diretórios Importantes
Quando você trabalha com DevOps, frequentemente interage com diretórios específicos. O /etc contém arquivos de configuração críticos — desde configurações de rede até configurações de serviços como Docker e Kubernetes. O /var/log é onde os logs do sistema são armazenados, fundamental para troubleshooting. O /opt é onde você instala aplicações de terceiros. O /home contém os diretórios pessoais dos usuários, enquanto /root é a home do usuário administrativo.
# Visualizar a estrutura de diretórios principais
ls -la /
# Entender o espaço utilizado em cada diretório
du -sh /*
# Ver informação detalhada sobre um diretório
ls -lh /var/log
Navegação Essencial no Terminal
Navegar no terminal Linux é uma habilidade que você aprenderá rápido, mas deve dominar completamente. Existem apenas alguns comandos fundamentais que você precisa internalizar: pwd (print working directory), cd (change directory), ls (list), e find (pesquisar). A combinação desses comandos resolve 90% das suas necessidades de navegação diária.
O pwd mostra em qual diretório você está no momento. É simples, mas extremamente útil especialmente em scripts onde você precisa saber a localização atual. O cd permite mudar de diretório — você pode usar caminhos absolutos (começando com /) ou caminhos relativos. Entender a diferença entre esses dois tipos de caminhos é crítico. Um caminho absoluto /home/user/projeto funciona de qualquer lugar, enquanto um caminho relativo ../projeto depende de onde você está.
Comandos Fundamentais de Navegação
# Ver o diretório atual
pwd
# Saída: /home/usuario
# Mudar para o diretório home
cd ~
# Voltar para o diretório anterior
cd -
# Subir um nível na hierarquia
cd ..
# Navegar para um caminho absoluto
cd /var/log
# Navegar para um caminho relativo (funciona de qualquer lugar dentro do seu home)
cd projeto/src
# Listar arquivos com detalhes (long format)
ls -la
# Listar apenas diretórios
ls -d */
# Listar recursivamente todos os arquivos
ls -R
# Encontrar arquivos por nome
find . -name "*.conf" -type f
# Encontrar arquivos modificados nos últimos 7 dias
find /var/log -type f -mtime -7
# Buscar por tamanho de arquivo (maior que 100MB)
find / -type f -size +100M
Atalhos e Produtividade no Terminal
Existem atalhos de teclado que aceleram enormemente seu trabalho. Ctrl+A leva você ao início da linha, Ctrl+E ao final, Ctrl+U apaga tudo até o início. Tab completa automaticamente nomes de arquivos e diretórios. Ctrl+R busca no histórico de comandos. Esses atalhos são padronizados na maior parte dos shells Linux e você deve usá-los automaticamente.
# Completar automaticamente nomes (pressione Tab)
cd /va[TAB] # Completa para /var/
# Buscar no histórico (pressione Ctrl+R)
[Ctrl+R]find # Busca o último comando que começa com 'find'
# Ver todo o histórico
history
# Executar o comando número 42 do histórico
!42
# Executar o último comando que começou com 'find'
!find
Sistema de Permissões e Controle de Acesso
As permissões no Linux são o mecanismo principal de segurança. Cada arquivo e diretório possui três tipos de permissões — leitura (r), escrita (w) e execução (x) — aplicadas a três categorias de usuários: proprietário (owner), grupo (group) e outros (others). Essa simplicidade é poderosa. Quando você vê rwxr-xr-x, está vendo um padrão que significa: o proprietário pode ler, escrever e executar; o grupo pode ler e executar; os outros podem ler e executar. Dominar esse sistema é fundamental para administração de sistemas e DevOps.
O comando chmod altera permissões e pode ser usado de duas formas: numérica ou simbólica. A forma numérica usa a notação octal onde r=4, w=2, x=1. Assim, chmod 755 significa 7 (4+2+1) para owner, 5 (4+1) para group, 5 (4+1) para others. A forma simbólica é mais legível: chmod u+rwx,g+rx,o+rx. O chown muda o proprietário, e chgrp muda o grupo. Para DevOps, você frequentemente trabalha com permissões de arquivos de configuração sensíveis e scripts executáveis.
Leitura e Modificação de Permissões
# Ver permissões detalhadas
ls -la /etc/passwd
# Saída típica: -rw-r--r-- 1 root root 1234 Dec 15 10:30 /etc/passwd
# Decodificação:
# - : tipo (- arquivo, d diretório, l link simbólico)
# rw- : permissões do proprietário (read, write, no execute)
# r-- : permissões do grupo (read, no write, no execute)
# r-- : permissões de outros (read, no write, no execute)
# Dar permissão de execução ao proprietário
chmod u+x script.sh
# Remover permissão de escrita para todos
chmod a-w arquivo.txt
# Definir permissões exatas (755 = rwxr-xr-x)
chmod 755 /home/user/aplicacao
# Definir permissões exatas (644 = rw-r--r--)
chmod 644 /home/user/config.conf
# Mudar proprietário
chown user:group arquivo.txt
# Mudar proprietário recursivamente
chown -R user:group /home/user/projeto
# Mudar apenas o grupo
chgrp developers /home/user/projeto
# Ver apenas proprietário e grupo
ls -l arquivo.txt | awk '{print $3, $4, $9}'
Permissões Especiais e Umask
Existem três permissões especiais que você encontrará em ambientes DevOps: setuid (4), setgid (2) e sticky bit (1). O setuid permite que um arquivo seja executado com as permissões do proprietário, não de quem o executa. O setgid faz algo similar para grupos. O sticky bit, comum em /tmp, impede que usuários deletem arquivos alheios. O umask define as permissões padrão para novos arquivos — ele funciona ao contrário, subtraindo de 777 (para diretórios) ou 666 (para arquivos).
# Ver umask atual
umask
# Saída típica: 0022
# Significa: arquivos criados com 644 (666-022) e diretórios com 755 (777-022)
# Mudar umask temporariamente
umask 0027
# Mudar umask permanentemente (adicione ao ~/.bashrc)
echo 'umask 0027' >> ~/.bashrc
# Verificar permissões especiais (setuid neste caso)
ls -l /usr/bin/sudo
# Saída: -rwsr-xr-x (note o 's' na posição do execute do owner)
# Adicionar setuid
chmod u+s arquivo
# Adicionar sticky bit (comum em /tmp)
chmod +t /tmp
# Remover setuid
chmod u-s arquivo
Operações Práticas: Casos de Uso em DevOps
Em um ambiente DevOps real, você constantemente trabalha com permissões de configuração, scripts e dados. Um cenário comum é garantir que um arquivo de configuração sensível (como credenciais de banco de dados) seja legível apenas pelo proprietário e pelo serviço que o executa. Outro cenário é garantir que scripts de deploy tenham permissão de execução apenas por membros específicos do grupo. Você também precisará entender como permissões afetam containers, volumes e compartilhamentos de arquivos.
Considere este cenário prático: você tem um serviço Systemd que roda como usuário appuser e precisa ler um arquivo de configuração. O arquivo deve estar legível apenas por esse usuário e pelo owner (root), sem exposição para outros. Você também terá scripts de automação que precisam ser executáveis apenas por administradores. Finalmente, você trabalhará com diretórios compartilhados em /opt ou /srv onde múltiplos usuários precisam colaborar, e aqui você usará permissões de grupo para garantir segurança sem ser restritivo demais.
Cenário Prático Completo
# Cenário: Preparar ambiente para aplicação Node.js que roda como 'nodeuser'
# 1. Criar diretório da aplicação com permissões corretas
mkdir -p /opt/minha-app
cd /opt/minha-app
# 2. Criar usuário específico para a aplicação
useradd -r -s /bin/false -d /opt/minha-app nodeuser
# 3. Criar diretório de logs
mkdir -p logs
chmod 755 .
chmod 750 logs
chown -R root:nodeuser .
chown nodeuser:nodeuser logs
# 4. Colocar arquivo de configuração sensível
cat > config.json << EOF
{
"db_password": "super_secreto_123",
"api_key": "xyz789"
}
EOF
# 5. Definir permissões: apenas nodeuser pode ler
chmod 600 config.json
chown nodeuser:nodeuser config.json
# 6. Criar script de deploy com permissões restritas
cat > deploy.sh << 'EOF'
#!/bin/bash
echo "Deploying..."
EOF
chmod 750 deploy.sh
chown root:wheel deploy.sh
# 7. Verificar permissões finais
ls -la /opt/minha-app
# -rwxr-x--- para scripts (750)
# -rw------- para config (600)
# -rwxr-xr-x para diretórios normais (755)
# 8. Testar acesso (troque para usuário nodeuser)
su - nodeuser -s /bin/bash
cat config.json # Funciona
exit
# 9. Tentar acesso como outro usuário (será negado)
su - outrousuario -s /bin/bash
cat /opt/minha-app/config.json # Permission denied
Conclusão
Três pontos fundamentais você deve levar deste artigo: Primeiro, o filesystem Linux é hierárquico e centralizado em /, com diretórios específicos servindo propósitos bem definidos — dominar essa estrutura permite navegar e gerenciar sistemas com confiança. Segundo, navegação eficiente no terminal depende de apenas alguns comandos bem utilizados (pwd, cd, ls, find) combinados com atalhos de teclado — isso se torna segunda natureza rapidamente. Terceiro, o sistema de permissões é simples mas poderoso — três permissões (r, w, x), três categorias de usuários (owner, group, others), e você controla acesso a praticamente qualquer recurso do sistema de forma granular e segura.
Para se tornar proficiente, pratique navegando pelo filesystem de um servidor ou VM Linux real. Crie arquivos, modifique permissões, tente acessá-los como usuários diferentes e veja os erros. Crie um usuário de aplicação fictício, dê a ele os privilégios mínimos necessários e verifique que funciona. Essa repetição é mais valiosa do que qualquer leitura teórica. No contexto de DevOps especificamente, você aplicará esses conhecimentos todos os dias: ao configurar permissões de arquivos em orchestração de containers, ao debugar problemas de acesso em CI/CD pipelines, ao estruturar volumes compartilhados entre ambientes.
Referências
- Linux Filesystem Hierarchy Standard (FHS): https://refspecs.linuxfoundation.org/FHS_3.0/fhs-3.0.pdf
- GNU Coreutils Manual - File Permissions: https://www.gnu.org/software/coreutils/manual/coreutils.html#File-permissions
- Linux man-pages project - chmod, chown, chgrp: https://man7.org/linux/man-pages/man1/chmod.1.html
- The Linux Command Line - William Shotts: https://linuxcommand.org/ (referência online gratuita)
- Ubuntu Manuals - File and Directory Permissions: https://manpages.ubuntu.com/manpages/focal/man1/ls.1.html