Do 'cd' ao Caos de Produção: O Guia Definitivo de Linux para Desenvolvedores

Todo desenvolvedor, mais cedo ou mais tarde, vai precisar encarar a linha de comando. Seja para criar uma pasta no seu ambiente local, rodar um container Docker ou conectar via SSH em um servidor de produção para caçar um bug de madrugada.

O problema é que muita gente trava no terminal por achar que ele é um labirinto complexo. Não é. O terminal é apenas uma ferramenta de produtividade.

Neste guia, vamos do absoluto zero — os comandos básicos de sobrevivência — até as combinações complexas que resolvem problemas reais de sistemas sob pressão.

## Parte 1: O Nível de Sobrevivência (Os Básicos)

Antes de apagar incêndios em produção, você precisa saber se mover pelo sistema. No Linux, você sempre está em algum diretório (pasta).

### pwd (Onde eu estou?)

Mostra o caminho absoluto da pasta onde você está pisando agora.

$ pwd
/home/usuario/meu-projeto-rails

### ls (O que tem aqui dentro?)

Lista os arquivos e pastas do diretório atual. No dia a dia, quase ninguém usa o ls puro. Usamos as flags -la para ver detalhes (permissões, tamanho, dono) e arquivos ocultos (como .env ou .gitignore).

$ ls -la

O que o terminal responde:

drwxr-xr-x  3 user user 4096 Jul 12 10:00 .
-rw-r--r--  1 user user  220 Jul 12 09:50 .env
-rw-r--r--  1 user user 1024 Jul 12 09:55 Gemfile
drwxr-xr-x  2 user user 4096 Jul 12 09:55 app

### cd (Navegando entre pastas)

Serve para entrar ou sair de diretórios.

• ▸Ir para uma pasta específica: cd app/models/
• ▸Voltar uma pasta para trás: cd ..
• ▸Ir direto para a pasta raiz do seu usuário (~): cd ou cd ~

### mkdir e touch (Criando coisas)

• ▸Criar uma pasta nova: mkdir nova-feature
• ▸Criar um arquivo em branco (ou atualizar a data dele): touch config/sidekiq.yml

### rm (Apagando coisas — cuidado aqui!)

• ▸Apagar um arquivo simples: rm temp.txt
• ▸Apagar uma pasta e tudo o que está dentro dela (recursivo e forçado): rm -rf pasta_velha/

## Parte 2: Manipulação e Visualização de Arquivos

Agora que você já sabe andar pelo servidor, precisa ler e editar configurações locais ou ler arquivos de logs.

### cat (Exibir o arquivo inteiro)

Mostra todo o conteúdo do arquivo na tela de uma vez. Útil apenas para arquivos pequenos.

$ cat config/database.yml

### nano ou vim (Editando direto no terminal)

Se precisar alterar uma variável de ambiente rápida direto no servidor. O nano é mais simples para iniciantes; o vim é o padrão da indústria, mas exige um pouco de treino.

$ nano .env
# Ctrl + O para salvar · Ctrl + X para sair

## Parte 3: O Jogo Avançado (Cenários Reais e Comandões Combinados)

Aqui é onde o filho chora e a mãe não vê. É o conhecimento necessário para misturar comandos usando o pipe (|), que joga a saída de um comando como entrada para o outro.

### Cenário A: A Porta Travada ("Address already in use")

Onde acontece: muito comum localmente quando você derruba seu app (Rails, Node) no Ctrl+C, mas o processo continua rodando em background e travando a porta.

Você precisa descobrir o ID do processo (PID) e matá-lo:

$ lsof -i :3000

O terminal responde:

COMMAND   PID USER   FD   TYPE DEVICE SIZE/OFF NODE NAME
ruby    28415 user    7u  IPv4  98123      0t0  TCP localhost:3000 (LISTEN)

Com o PID 28415 em mãos, você executa o tiro certeiro:

$ kill -9 28415

# Ou o "mata-tudo" em uma linha só:
$ lsof -t -i :3000 | xargs kill -9

### Cenário B: O Disco Cheio ("No space left on device")

Onde acontece: em produção, quando os arquivos de log ou uploads temporários engolem o SSD do seu servidor.

Verifique o espaço geral:

$ df -h

Descubra qual pasta é a vilã (ordenando por tamanho):

$ du -sh * 2>/dev/null | sort -rh | head -n 5

Se o terminal apontar que a pasta log/ tem 20GB, nunca apague o arquivo com rm. Use o comando abaixo para esvaziá-lo sem quebrar a aplicação que está escrevendo nele:

$ cat /dev/null > log/production.log

### Cenário C: Filtrando Logs de Erro em Tempo Real

Onde acontece: em produção, para acompanhar o comportamento do app após um deploy.

Você quer ver as requisições entrarem, mas só se importa se for um erro de banco ou um erro 500:

$ tail -f log/production.log | grep --line-buffered -E "ActiveRecord::|500 Internal"

O tail -f segue o arquivo em tempo real; o grep --line-buffered filtra as linhas instantaneamente.

### Cenário D: Processo Zumbi Consumindo 100% de CPU

Onde acontece: em produção, quando um worker do Sidekiq ou um loop infinito no código trava a máquina.

Se o servidor não tem o utilitário visual htop instalado, você encontra o culpado com o ps tunado:

$ ps -eo pid,ppid,%cpu,%mem,cmd --sort=-%cpu | head -n 6

O terminal responde:

  PID  PPID %CPU %MEM CMD
29481 29400 98.4  4.2 ruby app/workers/heavy_processor_worker.rb

Derrube o processo de forma educada para ele fechar as conexões com o banco antes de morrer:

$ kill -15 29481

## Tabela de Consulta Rápida (Do Básico ao Avançado)

## Conclusão

Dominar o Linux não é sobre decorar caminhos ou chaves de comandos bizarras. É sobre entender o fluxo: como navegar com segurança, como ler o que está acontecendo e como intervir quando as coisas travam. Comece praticando os básicos no seu terminal local e, quando precisar acessar a produção, use os comandos combinados para resolver o problema com precisão cirúrgica.