<h2>Entendendo o Filesystem Linux</h2>
<p>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.</p>
<p>A estrutura básica do filesystem segue um padrão estabelecido pelo Filesystem Hierarchy Standard (FHS). O diretório <code>/</code> é a raiz absoluta, e a partir dele temos diretórios importantes como <code>/home</code> (onde ficam os arquivos dos usuários), <code>/etc</code> (configurações do sistema), <code>/var</code> (dados variáveis como logs), <code>/bin</code> (programas executáveis), <code>/usr</code> (programas e bibliotecas do usuário) e <code>/root</code> (home do usuário root). Compreender essa estrutura é essencial para navegar eficientemente e gerenciar permissões de forma segura.</p>
<h3>Estrutura de Diretórios Importantes</h3>
<p>Quando você trabalha com DevOps, frequentemente interage com diretórios específicos. O <code>/etc</code> contém arquivos de configuração críticos — desde configurações de rede até configurações de serviços como Docker e Kubernetes. O <code>/var/log</code> é onde os logs do sistema são armazenados, fundamental para troubleshooting. O <code>/opt</code> é onde você instala aplicações de terceiros. O <code>/home</code> contém os diretórios pessoais dos usuários, enquanto <code>/root</code> é a home do usuário administrativo.</p>
<pre><code class="language-bash"># 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</code></pre>
<h2>Navegação Essencial no Terminal</h2>
<p>Navegar no terminal Linux é uma habilidade que você aprenderá rápido, mas deve dominar completamente. Existem apenas alguns comandos fundamentais que você precisa internalizar: <code>pwd</code> (print working directory), <code>cd</code> (change directory), <code>ls</code> (list), e <code>find</code> (pesquisar). A combinação desses comandos resolve 90% das suas necessidades de navegação diária.</p>
<p>O <code>pwd</code> 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 <code>cd</code> 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 <code>/home/user/projeto</code> funciona de qualquer lugar, enquanto um caminho relativo <code>../projeto</code> depende de onde você está.</p>
<h3>Comandos Fundamentais de Navegação</h3>
<pre><code class="language-bash"># 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</code></pre>
<h3>Atalhos e Produtividade no Terminal</h3>
<p>Existem atalhos de teclado que aceleram enormemente seu trabalho. <code>Ctrl+A</code> leva você ao início da linha, <code>Ctrl+E</code> ao final, <code>Ctrl+U</code> apaga tudo até o início. <code>Tab</code> completa automaticamente nomes de arquivos e diretórios. <code>Ctrl+R</code> busca no histórico de comandos. Esses atalhos são padronizados na maior parte dos shells Linux e você deve usá-los automaticamente.</p>
<pre><code class="language-bash"># 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</code></pre>
<h2>Sistema de Permissões e Controle de Acesso</h2>
<p>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ê <code>rwxr-xr-x</code>, 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.</p>
<p>O comando <code>chmod</code> 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, <code>chmod 755</code> significa 7 (4+2+1) para owner, 5 (4+1) para group, 5 (4+1) para others. A forma simbólica é mais legível: <code>chmod u+rwx,g+rx,o+rx</code>. O <code>chown</code> muda o proprietário, e <code>chgrp</code> muda o grupo. Para DevOps, você frequentemente trabalha com permissões de arquivos de configuração sensíveis e scripts executáveis.</p>
<h3>Leitura e Modificação de Permissões</h3>
<pre><code class="language-bash"># 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}'</code></pre>
<h3>Permissões Especiais e Umask</h3>
<p>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 <code>/tmp</code>, impede que usuários deletem arquivos alheios. O <code>umask</code> define as permissões padrão para novos arquivos — ele funciona ao contrário, subtraindo de 777 (para diretórios) ou 666 (para arquivos).</p>
<pre><code class="language-bash"># 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</code></pre>
<h2>Operações Práticas: Casos de Uso em DevOps</h2>
<p>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.</p>
<p>Considere este cenário prático: você tem um serviço Systemd que roda como usuário <code>appuser</code> 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 <code>/opt</code> ou <code>/srv</code> onde múltiplos usuários precisam colaborar, e aqui você usará permissões de grupo para garantir segurança sem ser restritivo demais.</p>
<h3>Cenário Prático Completo</h3>
<pre><code class="language-bash"># 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</code></pre>
<h2>Conclusão</h2>
<p>Três pontos fundamentais você deve levar deste artigo: Primeiro, o filesystem Linux é hierárquico e centralizado em <code>/</code>, 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 (<code>pwd</code>, <code>cd</code>, <code>ls</code>, <code>find</code>) 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.</p>
<p>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.</p>
<h2>Referências</h2>
<ul>
<li><strong>Linux Filesystem Hierarchy Standard (FHS)</strong>: https://refspecs.linuxfoundation.org/FHS_3.0/fhs-3.0.pdf</li>
<li><strong>GNU Coreutils Manual - File Permissions</strong>: https://www.gnu.org/software/coreutils/manual/coreutils.html#File-permissions</li>
<li><strong>Linux man-pages project - chmod, chown, chgrp</strong>: https://man7.org/linux/man-pages/man1/chmod.1.html</li>
<li><strong>The Linux Command Line - William Shotts</strong>: https://linuxcommand.org/ (referência online gratuita)</li>
<li><strong>Ubuntu Manuals - File and Directory Permissions</strong>: https://manpages.ubuntu.com/manpages/focal/man1/ls.1.html</li>
</ul>
<p><!-- FIM --></p>