“A porta está em uso” num servidor
A primeira linha da busca reversa: ss -tulnp | grep :8080 para achar o PID, depois kill <PID> ou direto kill -9 $(lsof -t -i :8080).
Carregando…
Guide
O Guia rápido de comandos Linux organiza os 160 comandos que você digita no terminal todos os dias em oito grupos — arquivos e diretórios, ver e editar conteúdo, processamento de texto, permissões e usuários, processos e serviços, rede, compactação e empacotamento, e informações e administração do sistema — cada um com uma explicação curta e algumas linhas de exemplo prontas para copiar; comandos com muitas opções, como ls, find, grep, sed, awk, tar, curl, ss e journalctl, trazem ainda uma tabela de opções comuns que abre no lugar.
Atualizado em 2026-09-094 sources9 min read
O Guia rápido de comandos Linux organiza os 160 comandos que você digita no terminal todos os dias em oito grupos — arquivos e diretórios, ver e editar conteúdo, processamento de texto, permissões e usuários, processos e serviços, rede, compactação e empacotamento, e informações e administração do sistema — cada um com uma explicação curta e algumas linhas de exemplo prontas para copiar; comandos com muitas opções, como ls, find, grep, sed, awk, tar, curl, ss e journalctl, trazem ainda uma tabela de opções comuns que abre no lugar.
Ele resolve dois tipos de busca. Um é saber o nome do comando e esquecer os parâmetros (busque tar, chmod). O outro é saber apenas o que você quer ver — “qual processo está na porta 8080”, “qual diretório está ocupando mais disco”, “por que este serviço não subiu” — e para isso existe a busca reversa “quero ver… → qual comando”: primeiro o objetivo, depois 2–3 comandos que chegam lá, do recomendado ao compatível.
No fim da página há um terminal simulado que roda no navegador: sistema de arquivos em memória mais um interpretador de shell para mais de 60 comandos, com pipes, redirecionamento, curingas e um subconjunto comum de sed/awk, e 8 níveis de prática, de montar uma estrutura de diretórios a contar logs com pipes. Ele não acessa o seu computador nem tem rede, então um rm -rf digitado errado só reinicia o nível.
help lista todos os comandos que o simulador aceita e Tab completa nomes de arquivo.Buscar “porta” encontra tanto a tabela de comandos quanto a busca reversa:
Uma solução completa do nível 8, “combinações de pipe”, no terminal simulado:
Quero ver: qual processo está usando uma porta
ss -tulnp | grep :8080
lsof -i :8080
netstat -tulnp | grep 8080 sistemas antigos
Rede › ss -tulnp portas à escuta e os processos correspondentes (substitui o netstat)
Rede › lsof -i :<porta> qual processo está usando uma portauser@toolun-lab:~$ awk '{print $2}' access.log | sort | uniq -c | sort -rn
3 /index.html
2 /api/list
2 /about
✔ Concluído: combinações de pipe: os caminhos mais acessados.Dois princípios do design Unix definem o formato desta tabela. “Tudo é arquivo”: dispositivos, informações de processo (/proc) e sockets aparecem como arquivos, e é por isso que usos aparentemente estranhos como cat /proc/cpuinfo, ls -l /dev/sd* e echo > /dev/tcp/host/port funcionam. “Cada programa faz uma coisa e a faz bem”: grep só filtra, sort só ordena, uniq só junta repetições adjacentes, wc só conta — cada um é pequeno sozinho, e a força vem de encadear tudo com pipes.
É por isso que o | aparece tanto nos exemplos: awk '{print $1}' access.log | sort | uniq -c | sort -rn | head monta “os IPs que mais acessaram” com cinco programinhas. Entender a entrada e a saída de cada trecho é mais útil do que decorar o comando inteiro.
Todo processo começa com três “arquivos” abertos: entrada padrão (0), saída padrão (1) e erro padrão (2). O > grava a saída padrão num arquivo, o 2> trata o fluxo de erro, o 2>&1 junta o erro à saída e o &> é um atalho do bash. A combinação mais comum do dia a dia é cmd > out.log 2>&1 &: saída normal e erros vão para o log, e a tarefa vai para segundo plano. Esquecer o 2>&1 é a causa número um de “por que não tem erro no log”.
A primeira coluna do ls -l, como -rwxr-xr-x, tem quatro partes: o tipo (- arquivo, d diretório, l link) e, para dono, grupo e demais usuários, as permissões de leitura (4), escrita (2) e execução (1). Somando os três dígitos chega-se à forma numérica: rwx=7, r-x=5, r--=4, então 755 é “eu posso tudo, os outros só leem e executam” e 644 é “eu leio e escrevo, os outros só leem”. Em diretórios, o x significa “pode entrar”: um diretório sem x não lista o conteúdo nem com r. Já 600/700 são para chaves privadas e para o ~/.ssh — clientes SSH recusam arquivos de chave com permissão frouxa. Outras combinações podem ser montadas na Calculadora chmod.
O nome kill engana: ele só envia um sinal ao processo. O TERM (15), padrão, é “por favor, saia”, e o programa tem chance de salvar o estado; o KILL (9) é o kernel terminando na hora, sem chance nenhuma — então mande kill, espere alguns segundos e só depois use kill -9. O HUP (1) é a convenção de “recarregar a configuração” em daemons; o nginx -s reload usa isso por baixo.
As distribuições modernas gerenciam serviços com systemd: o systemctl liga, desliga e habilita no boot, e o journalctl reúne os logs deles. O caminho fixo para “o serviço não sobe” é systemctl status para ver o estado e as últimas linhas do log → journalctl -u <serviço> -n 100 para o erro completo → ss -tlnp para ver se a porta já está ocupada.
ifconfig, netstat, route e arp pertencem ao net-tools, sem manutenção, e os sistemas novos não os instalam por padrão; os substitutos no iproute2 são ip addr, ss, ip route e ip neigh. O guia lista os dois, e a busca reversa coloca as ferramentas novas na frente. As cinco letras de ss -tulnp são TCP, UDP, escuta, portas numéricas e processos — quase sempre a abertura de qualquer investigação de porta.
O sed do GNU aceita -i sem argumento; o sed do BSD (o que vem no macOS) exige um sufixo de backup depois de -i, então se escreve sed -i '' 's/a/b/' file. Diferenças parecidas aparecem em date -d (GNU) contra date -v (BSD) e no readlink -f, que não existe em macOS antigos. O guia segue a versão GNU e anota as diferenças do macOS nas observações de cada entrada; brew install coreutils gnu-sed instala as versões GNU.
yast), comandos de ambiente gráfico e CLIs próprias de linguagens ficam de fora.sed só aceita s///, N,Mp e Nd, e awk só {print $N}; não há rede (curl, ssh e apt explicam o motivo), nem processos reais (ps, top e kill devolvem dados fixos de demonstração), nem editores interativos (escreva arquivos com echo > ou cat >>).A primeira linha da busca reversa: ss -tulnp | grep :8080 para achar o PID, depois kill <PID> ou direto kill -9 $(lsof -t -i :8080).
O grupo de processamento de texto é um kit completo, do grep -A3 -B1 para ver contexto ao awk/sort/uniq -c para estatística e ao tail -F para logs que giram; os níveis 3 e 8 do terminal de prática são exatamente essas duas tarefas.
tar -czvf → scp / rsync -avz → tar -xzvf -C /var/www/, três entradas vizinhas; a armadilha do rsync --delete está nas observações.
Percorra o grupo de informações e administração do sistema na ordem cat /etc/os-release, nproc, free -h, df -h, ss -tlnp, systemctl list-units e em dez minutos você tem o panorama.
Na prática, não. O Linux não tem lixeira e o rm libera o inode direto. Antes de mexer num diretório importante, confirme o caminho com ls; em scripts, coloque aspas nas variáveis e proteja contra valor vazio (rm -rf "${DIR:?}"/), ou troque o rm por ferramentas como o trash-cli.
Na maioria dos casos a codificação do terminal ou do arquivo não bate. Rode file nome-do-arquivo para ver a codificação, converta arquivos GBK para UTF-8 com iconv -f GBK -t UTF-8 e busque de novo; o grep -a trata como texto arquivos que foram detectados como binários por engano.
As colunas de ss -tulnp são Netid, State, Recv-Q, Send-Q, Local Address:Port, Peer Address:Port e Process. Para achar a porta, olhe Local Address:Port (*:8080 ou 0.0.0.0:8080 indica todas as interfaces); para achar o processo, olhe a última coluna, users:(("node",pid=842,fd=18)).
Ele roda no navegador, não tem pilha de rede e não deve enviar requisições no seu lugar; esses comandos devolvem uma explicação e apontam para a entrada correspondente do guia. O foco dos níveis são arquivos, texto e permissões, que funcionam por completo no sistema de arquivos em memória.
Ler arquivos para os quais você já tem permissão não precisa de nada; alterar diretórios do sistema (/etc, /usr), vincular portas abaixo de 1024, ver detalhes de processos de outros usuários e gerenciar serviços e pacotes exigem root. O sudo executa um comando como root, o que é mais seguro do que passar para root por muito tempo.
Os dados do guia, a busca reversa e o terminal simulado são conteúdo estático baixado com a página e executado no navegador; buscar, copiar e praticar não enviam requisição alguma. Os favoritos ficam no localStorage deste aparelho. O sistema de arquivos do terminal simulado existe apenas na memória da página atual, é apagado ao atualizar e nunca lê nem grava seus arquivos reais.
ls, cp, sort e cut.ss(8), ip(8), find(1) e grep(1).Atualizado em 2026-09-09
160 comandos Linux/Shell agrupados por arquivos, texto, permissões, processos, rede, compactação e sistema, com tabelas de opções e exemplos reais; índice reverso «o que quero ver → qual comando usar»; busca, cópia, favoritos e terminal de prática
Esta ferramenta ainda não está totalmente traduzida; parte do conteúdo usa o idioma de origem ou um idioma de reserva.
Busca reversa pelo objetivo de saída: primeiro você diz o que quer saber e recebe 2–3 comandos que mostram isso, do mais novo ao mais antigo e do recomendado ao compatível.
pwd # /var/www/site
ls -la # detalhado + arquivos ocultos ls -lh # tamanho legível por humanos ls -lt | head # Veja o último na ordem inversa do horário da modificação
| -l | Formato longo: permissões, proprietário, tamanho, hora |
| -a | Contém arquivos ocultos começando com . |
| -h | Tamanho em K/M/G |
| -t | Classificar por horário de modificação |
| -S | Classificar por tamanho |
| -R | Subdiretório recursivo |
| -d | Liste apenas o diretório em si e não entre nele |
cd /var/log cd .. # Nível anterior cd - # Retorna ao diretório anterior cd # Diretório inicial (igual a cd ~)
mkdir -p app/src/{components,utils}
mkdir -m 700 private| -p | Crie recursivamente, nenhum erro será relatado se já existir |
| -m | Especifique permissões |
| -v | Mostrar o que foi criado |
touch README.md touch -d "2026-01-01" old.log # Especifique a hora
cp a.txt b.txt cp -r src/ backup/ # Diretório requer -r cp -a /etc/nginx ~/nginx-bak # Reserve permissões e tempo
| -r / -R | Copiar diretórios recursivamente |
| -a | Arquivo: igual a -dR --preserve=all |
| -i | Pergunte antes da cobertura |
| -n | Não sobrescreva os arquivos existentes |
| -u | Copie apenas quando a fonte for atualizada |
| -v | mostrar processo |
mv antigo.txt novo.txt # Renomear mv *.log logs/ # Movimentação em lote mv -i a.txt dir/ # Pergunte antes de substituir
| -i | Pergunte antes da cobertura |
| -n | Não coberto |
| -f | Cobertura de força |
| -v | mostrar processo |
rm file.txt rm -r build/ # Exclui diretório rm -rf node_modules # Não confirme ou ignore a inexistência
rm não entra na lixeira. Antes de rm -rf, faça eco da variável de caminho para ver se ela está vazia: rm -rf "$DIR"/ é igual a rm -rf / quando DIR está vazio.
| -r | Excluir diretórios recursivamente |
| -f | Não pergunte, ignore que isso não existe |
| -i | Confirme um por um |
| -d | Exclua diretórios vazios |
| -- | Os seguintes parâmetros são opções inadequadas (exclua arquivos começando com -) |
rmdir empty-dir rmdir -p a/b/c # junto com o diretório pai vazio
ln -s /opt/app/current ~/app ln -sf link new-target # Substitui links existentes readlink -f link # Veja para onde o link aponta
find . -name "*.log"
find /var -type f -size +100M # Arquivos maiores que 100MB
encontrar . -mtime -7 -name "*.js" # Modificado em 7 dias
find . -name "*.tmp" -delete
find . -type f -exec chmod 644 {} \;| -name / -iname | Por nome (-iname ignora maiúsculas e minúsculas) |
| -type f|d|l | Arquivo/Diretório/Link |
| -size +10M / -1k | por tamanho |
| -mtime -N / +N | Modificado dentro de N dias/N dias atrás |
| -maxdepth N | limite de profundidade |
| -exec cmd {} \; | Execute o comando para cada resultado |
| -delete | Remover correspondências |
| -empty | Arquivo ou diretório vazio |
sudo updatedb locate nginx.conf
which python3 digite ls # bash integrado, você pode ver aliases/comandos integrados/externos command -v node # Determine se o comando existe no script
tree -L 2 tree -a -I "node_modules|.git" # exclui
file photo.bin # photo.bin: JPEG image data, ...
stat app.log stat -c "%s %n" * # Apenas tamanho e nome
du -sh . du -sh * | classificar -rh | head# Quem ocupa mais espaço du -h --max-depth=1 /var
| -s | Mostrar apenas o total |
| -h | legível por humanos |
| --max-depth=N | Nível de restrição |
| -a | Contém arquivos |
df -h df -h /home df -i # uso de inode (completo quando há muitos arquivos)
basename /var/log/syslog # syslog basename report.pdf .pdf # report dirname /var/log/syslog # /var/log
realpath ../config.yml
rsync -avz --progress src/ user@host:/srv/app/ rsync -av --delete ./dist/ /var/www/site/ # Exclua também arquivos redundantes no destino rsync -avn src/ dst/ # -n somente visualização
A presença ou ausência de / no final do diretório de origem tem significados diferentes: src/ sincroniza o conteúdo e src sincroniza o próprio diretório.
| -a | Modo de arquivamento (recursivo + retenção de atributos) |
| -v | mostrar processo |
| -z | compressão de transmissão |
| --delete | Exclua arquivos redundantes no lado de destino |
| -n / --dry-run | Apenas visualização |
| --exclude=PAT | excluir |
| -P | Progresso + retomada do ponto de interrupção |
scp app.tar.gz user@1.2.3.4:/tmp/ scp -r user@host:/var/log/app ./logs scp -P 2222 arquivo user@host:~ # Especifique a porta (P maiúsculo)
cat config.yml cat -n app.js # com número de linha cat a.txt b.txt > all.txt # Emenda
| -n | Número da linha |
| -A | Exibir caracteres invisíveis (^M é CRLF) |
| -s | Compactar linhas em branco consecutivas |
less /var/log/syslog #/pesquisa por palavra-chave n próximo G até o final g até o início q saída F seguir (como tail -f)
| -N | Mostrar número da linha |
| -S | Não quebre a linha |
| +F | Entre no modo de acompanhamento |
| -i | A pesquisa ignora maiúsculas e minúsculas |
head -n 20 app.log head -c 100 arquivo.bin # primeiros 100 bytes head -n -5 arquivo # exceto as últimas 5 linhas
tail -n 50 app.log tail -f /var/log/nginx/access.log tail -F app.log # Continue a seguir depois que o arquivo for girado
| -n N | Próximas N linhas |
| -f | Siga e adicione |
| -F | Acompanhe e cuide da reconstrução de arquivos |
| -n +N | Da linha N até o fim |
wc -l access.log é | wc -l #Quantos itens existem no diretório? gato *.py | wc -l # Número de linhas de código
diff -u old.conf new.conf diff -r dir1 dir2 # Compara diretórios diff <(sort a) <(sort b) # Compara o conteúdo classificado
| -u | formato unificado |
| -r | Compare diretórios recursivamente |
| -q | Relate apenas se for diferente |
| -w | ignore o espaço em branco |
| -i | Ignorar caso |
cmp a.bin b.bin
nl -ba script.sh # Linhas vazias também são numeradas
tac app.log | less
strings app.bin | grep -i version
xxd file.bin | head -20 xxd -r dump.txt > arquivo.bin # Restaurar
nano /etc/hosts # Ctrl+O Salvar Ctrl+X Sair Ctrl+W Pesquisar Ctrl+K Cortar linha
vim app.conf # :wq Salve e saia :q! Sair sem salvar / pesquisa por palavra dd excluir linha e desfazer: definir o número da linha nu
make 2>&1 | tee build.log ecoar "texto" | sudo tee /etc/file # Use sudo para gravar arquivos protegidos cmd | tee -a log.txt # Anexar
ls > list.txt echo "line" >> notes.txt cmd > out.log 2>&1 # Registra tudo cmd 2>/dev/null # descarta erros cmd &> all.log # abreviatura do bash
ps aux | grep nginx cat log | grep ERROR | wc -l history | tail -20
grep -rn "TODO" src/
grep -i error app.log
grep -v "^#" nginx.conf | grep -v "^$" # Remove comentários e linhas em branco
grep -E "5[0-9]{2}" access.log # Expressão regular estendida
grep -l "main" *.c # Lista apenas nomes de arquivos
grep -A3 -B1 "Exception" app.log # Primeira 1 e últimas 3 linhas de contexto| -r / -R | diretório recursivo |
| -n | Mostrar número da linha |
| -i | Ignorar caso |
| -v | Seleção invertida (linhas sem padrão) |
| -E | Expressão regular estendida (igual a egrep) |
| -F | como string fixa |
| -w | correspondência de palavra inteira |
| -c | Basta contar o número de linhas |
| -l | Listar apenas nomes de arquivos correspondentes |
| -o | Produza apenas a parte correspondente |
| -A/-B/-C N | Depois/antes/antes e depois de N linhas de contexto |
| --include="*.js" | Limitar nomes de arquivos ao recorrer |
rg "TODO" --type ts
rg -n "fetch\(" src/sed 's/foo/bar/g' a.txt # Produz o resultado da substituição sed -i 's/foo/bar/g' a.txt # Modifica arquivos diretamente (GNU) sed -i.bak 's/8080/80/' app.conf # Faça um backup antes de fazer alterações sed 's#/usr/local#/opt#g' f # O delimitador pode ser substituído
| -i | Modifique no local (macOS requer -i '') |
| -n | Imprima apenas as linhas selecionadas pelo comando p |
| -e | vários scripts |
| -E | regular estendido |
| bandeira g | Substitua tudo em uma linha |
sed -n '10,20p' app.log # Linhas 10–20 sed '5d' f.txt # Excluir linha 5 sed '/^$/d' f.txt # Exclui linhas vazias sed '3i\new line' f.txt # Inserir antes da linha 3
awk '{print $1}' access.log | classificar | único -c | classificar -rn | head # Os IPs mais visitados
awk -F: '{print $1}' /etc/passwd # nome de usuário
awk '$3 > 100 {print $0}' data.txt # A terceira coluna é maior que 100 linhas
awk '{soma += $2} END {imprimir soma}' f # Soma| -F <separador> | Separador de campos (padrão em branco) |
| $0 / $1 / $NF | Linha inteira/1ª coluna/última coluna |
| NR | Número da linha atual |
| BEGIN{} / END{} | Executar antes do início/depois do fim |
| /regular/{…} | Processar apenas linhas correspondentes |
cut -d, -f1,3 data.csv cut -d: -f1 /etc/passwd cortar -c1-8 arquivo # por posição do caractere
sort names.txt sort -n nums.txt # Por valor numérico sort -k2 -t, -r data.csv # Classifica pela coluna 2 na ordem inversa sort -u list.txt # Classifica e remove duplicatas sort -h tamanhos.txt # De acordo com o tamanho K/M/G
| -n | por valor |
| -r | ordem inversa |
| -k N | pela coluna N |
| -t <separador> | Separador de colunas |
| -u | Remover duplicatas |
| -h | tamanho legível por humanos |
| -V | Classificação do número de versão (1.2 <1.10) |
sort words.txt | uniq -c | sort -rn classificar a.txt | uniq -d # Mostra apenas duplicatas classificar a.txt | uniq -u # Exibe apenas os únicos
echo hello | tr a-z A-Z # HELLO tr -d '\r' <win.txt> unix.txt # Remover CR tr -s ' ' < f # Compacta espaços consecutivos echo $PATH | tr ':' '\n' # Um por linha
find . -name "*.log" | xargs rm
encontrar . -nome "*.txt" -print0 | xargs -0 wc -l # O nome do arquivo contém espaços
URLs de gato.txt | xargs -n1 -P4 curl -sO # paralelo de 4 vias
echo a b c | xargs -I{} echo "item: {}"| -0 | NUL separado (com find -print0) |
| -n N | Passe N parâmetros de cada vez |
| -I {} | Use {} para ocupar espaço |
| -P N | N paralelo |
| -r | Não execute quando a entrada estiver vazia |
paste -d, names.txt emails.txt
join -t, -1 1 -2 1 <(sort a.csv) <(sort b.csv)
cat /etc/fstab | column -t mount | column -t
echo abc | rev # cba
fold -w 80 -s long.txt # -s fold nos espaços
iconv -f GBK -t UTF-8 gbk.txt > utf8.txt íconev -l | grep -i gb # Lista as codificações suportadas
dos2unix script.sh sed -i "s/\r$//" script.sh # Quando dos2unix não está instalado
curl -s https://api.github.com/repos/git/git | jq .stargazers_count jq ".items[] | .name" data.json jq -r ".[].id" list.json # -r string original sem aspas gato a.json | jq. # Formatação
echo "Hello" echo -e "a\tb\nc" echo $HOME echo "PATH=$PATH" >> ~/.bashrc
printf "%-10s %5d\n" name 42 printf "%.2f\n" 3.14159 printf "%s\n" *.txt # Um nome de arquivo por linha
seq 1 10 seq 0 5 100 # tamanho do passo 5 for i in $(seq 1 3); do echo $i; done
echo "2^10" | bc echo "scale=3; 10/3" | bc echo "obase=16; 255" | bc# Converte para hexadecimal
chmod 755 script.sh # rwxr-xr-x chmod 644 file.txt # rw-r--r-- chmod 600 ~/.ssh/id_ed25519 # Só você pode ler e escrever chmod -R 755 público/ # recursivo
| 755 | Valores comuns para diretório/executável |
| 644 | Valores comuns para arquivos comuns |
| 600 | Arquivos de chave privada e senha |
| 700 | Diretório privado (como ~/.ssh) |
| -R | recursão |
chmod +x deploy.sh # Adiciona executável chmod u+w,go-w file # O proprietário pode escrever, outros não chmod a-x file chmod g+s shared/ # Diretório setgid: novo grupo de herança de arquivo
sudo chown www-data:www-data -R /var/www/site sudo chown $USER file.txt projeto de desenvolvedores chgrp/ # apenas embaralhar
umask umask 027 # Grupo somente leitura, outros não têm permissões
sudo apt update sudo -i # Muda para shell interativo root sudo -u postgres psql # Executa como outro usuário sudo!! # Use sudo para executar novamente o anterior
su - deploy sair #voltar
whoami id id implantar # Ver outros usuários
sudo useradd -m -s /bin/bash deploy sudo passwd deploy sudo usermod -aG sudo deploy # Junte-se ao grupo sudo
sudo usermod -aG docker $USER newgrp docker # Ou faça login novamente para entrar em vigor
sudo userdel -r olduser
passwd sudo passwd deploy sudo passwd -l deploy # Bloqueia conta
groups groups www-data cat /etc/group | grep docker
who w last -n 10 lastlog
ssh-keygen -t ed25519 -C "me@example.com" cat ~/.ssh/id_ed25519.pub ssh-copy-id user@host # Instala a chave pública no servidor
ssh user@1.2.3.4 ssh -p 2222 usuário@host #Especificar porta ssh -i ~/.ssh/key.pem ubuntu@host ssh -L 8080:localhost:80 user@host # Encaminhamento de porta ssh user@host "uptime" # Executa apenas um comando
| -p | porta |
| -i | arquivo de chave privada |
| -L local:alvo:porta | encaminhamento de porta local |
| -N | Apenas o encaminhamento não abre o shell |
| -v | Depurando problemas de conexão |
Host prod
HostName 1.2.3.4
User deploy
Port 2222
IdentityFile ~/.ssh/prod_keyps aux | grep nginx ps -ef | grep java ps aux --sort=-%mem | head # O que mais consome memória ps -p 1234 -o pid,etime,cmd # Há quanto tempo um processo está em execução?
| aux | Estilo BSD: todos os usuários, incluindo terminais, detalhado |
| -ef | Estilo UNIX: todos os processos, incluindo o processo pai |
| --sort=-%cpu | Classifique por CPU na ordem inversa |
| -p PID | Especifique o processo |
| -o campo | Colunas personalizadas |
pgrep -f "node server.js" pgrep -l nginx # com nome pkill -f "node server.js" # Encontre e mate
top top -o %MEM top -p 1234 # Visualiza apenas um determinado processo
htop htop -u www-data
kill 1234 kill -9 1234 # Mate se for desobediente kill -HUP 1234 # Deixe o serviço recarregar a configuração kill -l # lista de sinais
| -15 / -TERM | Padrão: Solicitar saída normal |
| -9 / -KILL | Fim forçado sem dar chance de limpar |
| -1 / -HUP | Comumente usado para sobrecarregar a configuração |
| -2 / -INT | Igual a Ctrl+C |
| -STOP / -CONT | Pausar/Retomar |
killall node killall -9 chrome
npm run build & jobs fg %1 # Ctrl+Z pausa a tarefa atual em primeiro plano e então bg para continuá-la em segundo plano
nohup python server.py > server.log 2>&1 & eco $! # PID acabou de começar
tmux new -s work # Ctrl+B e depois d para separar tmux ls tmux attach -t work tmux kill-session -t work
systemctl status nginx systemctl status --failed # Serviço com falha
sudo systemctl restart nginx sudo systemctl reload nginx # Recarrega a configuração sem interromper a conexão
sudo systemctl enable --now docker sudo systemctl disable apache2 systemctl is-enabled nginx
systemctl list-units --type=service --state=running systemctl list-unit-files | grep enabled
journalctl -u nginx -f journalctl -u app -n 200 --no-pager journalctl --since "1 hour ago" journalctl -p err -b # Erros desde esta inicialização sudo journalctl --vacuum-size=500M # Limpar
| -você <unidade> | um serviço |
| -f | seguir |
| -n N | Últimas N linhas |
| --since / --until | intervalo de tempo |
| -p err | Filtrar por nível |
| -b | Esta inicialização |
| -k | Mensagens do kernel |
crontab -e # Backup todos os dias às 15h30 30 3 * * * /opt/scripts/backup.sh >> /var/log/backup.log 2>&1 # a cada 5 minutos */5 * * * * /usr/bin/curl -s https://example.com/ping crontab -l # Ver
echo "systemctl restart app" | at 03:00 atq #fila atrm 3 # excluir
watch -n 2 "df -h" watch -d free -m # -d destacar alterações
time ./build.sh time curl -s https://example.com > /dev/null
timeout 10 ping example.com timeout -s KILL 30 ./stuck.sh
lsof -p 1234 lsof +D /var/log # Quem está usando os arquivos neste diretório? lsof | grep excluído # Arquivos excluídos, mas ocupados (o disco não é liberado)
strace -p 1234 strace -f -e trace=network node app.js strace -c ./cmd # Estatísticas
nice -n 19 tar czf big.tgz data/ renice -n 10 -p 1234
ss -tulnp ss -tlnp | grep :80 ss -s # estatísticas de conexão ss -tan state established
| -t / -u | TCP / UDP |
| -l | Apenas monitore |
| -n | A porta numérica não resolve o nome do serviço |
| -p | Mostrar processos (requer root para ver todos) |
| -a | Conecte tudo |
netstat -tulnp | grep 3000 netstat -an | grep ESTABLISHED | wc -l
lsof -i :8080 lsof -i tcp -sTCP:LISTEN kill -9 $(lsof -t -i :3000) # Mate o ocupante diretamente
ip addr ip -4 -br endereço # simplificar nome do host -I # Somente IP
ip route ip route get 8.8.8.8 # Qual caminho seguir para um determinado endereço?
ping -c 4 example.com ping -i 0.2 -c 20 10.0.0.1
traceroute example.com mtr -rw example.com
curl -I https://example.com # Ler apenas cabeçalhos de resposta
curl -sS https://api.example.com/x | jq. # Silencioso mas reportando um erro
curl -o file.zip -L https://…/file.zip # Baixe e siga os redirecionamentos
curl -X POST -H "Content-Type: application/json" -d '{"a":1}' https://api.example.com/items
curl -u user:pass https://…
curl -w "%{http_code} %{time_total}\n" -o /dev/null -s https://example.com| -I | Solicitar apenas cabeçalho (HEAD) |
| -L | seguir redirecionamento |
| -o arquivo / -O | Salvar em arquivo/usando nome de arquivo remoto |
| Método -X | Método de solicitação |
| -H "cabeçalho: valor" | Cabeçalho da solicitação |
| -d dados | Corpo da solicitação (POST padrão) |
| -s / -S | Silencioso/silencioso com erros |
| -v | Mostrar interação completa |
| -k | Ignorar erros de certificado (para depuração) |
| -w formato | Código de status de saída, consumo de tempo, etc. |
wget https://example.com/file.tar.gz wget -c https://…/big.iso # Continuar download wget -qO- https://example.com | head # Saída para a tela wget -r -np -nH --cut-dirs=1 https://example.com/docs/
dig example.com dig +short example.com dig MX example.com dig @8.8.8.8 example.com # Especifique DNS dig -x 93.184.216.34 # Verificação reversa
nslookup example.com nslookup -type=txt example.com
host example.com
sudo nano /etc/hosts 127.0.0.1 dev.example.com
nc -zv example.com 443 nc -l 8080 #Monitor 8080 eco "oi" | nc host 8080 # Envia dados
telnet smtp.example.com 25
sudo ufw status sudo ufw allow 22 sudo ufw allow 80/tcp sudo ufw allow from 10.0.0.0/8 to any port 5432 sudo ufw enable
Certifique-se de liberar 22 antes de abri-lo, caso contrário, o SSH será bloqueado sozinho.
sudo firewall-cmd --list-all sudo firewall-cmd --add-port=8080/tcp --permanent sudo firewall-cmd --reload
sudo iptables -L -n -v --line-numbers sudo iptables -A INPUT -p tcp --dport 8080 -j ACCEPT
sudo tcpdump -i eth0 port 80 -nn sudo tcpdump -i qualquer host 10.0.0.5 -w cap.pcap # Salve o arquivo no Wireshark
sudo iftop -i eth0 nload
ip neigh arp -a
tar -czvf site.tar.gz site/ tar -czf logs.tgz --exclude="*.tmp" logs/ tar -cJvf site.tar.xz site/ # xz compacta menor e mais lento
| -c | criar |
| -x | Desatar |
| -t | listar conteúdo |
| -z / -j / -J | gzip / bzip2 / xz |
| -v | mostrar arquivo |
| -f arquivo | Nome do arquivo compactado (deve seguir o nome do arquivo) |
| -C diretório | Mude para o diretório e opere |
| --exclude=PAT | excluir |
tar -xzvf site.tar.gz tar -xzvf site.tar.gz -C /var/www/ tar -xf any.tar.* # A nova versão do tar reconhece automaticamente o formato de compactação tar -tzvf site.tar.gz # Vamos ver o que tem dentro primeiro
gzip big.log # obtenha big.log.gz gzip -k big.log # Mantém o arquivo original gunzip big.log.gz zcat big.log.gz | grep ERROR # Visualize diretamente sem descompactar
zip -r project.zip project/ -x "*/node_modules/*" zip -e secret.zip arquivo.txt # Criptografia
unzip archive.zip unzip archive.zip -d out/ unzip -l archive.zip # apenas visualiza a lista unzip -O gbk cn.zip # Quando os nomes de arquivos chineses do Windows estão ilegíveis
7z x archive.7z 7z a -mx9 out.7z dir/ 7z x file.rar
xz -9 big.sql xz -d big.sql.xz bzip2 -k file
split -b 100M big.iso part_ cat part_* > big.iso
sha256sum ubuntu.iso sha256sum -c SHA256SUMS md5sum file.zip
sudo dd if=ubuntu.iso of=/dev/sdX bs=4M status=progress && sync dd if=/dev/zero of=test.bin bs=1M count=100 # arquivo de teste de 100MB
of= Se você gravar no dispositivo errado, o disco será apagado diretamente. Confirme com lsblk três vezes antes de executar.
uname -a uname -m # x86_64 / aarch64 cat /etc/os-release # Versão de lançamento
hostnamectl sudo hostnamectl set-hostname web-01
uptime # Load > Número de núcleos de CPU (nproc) indica enfileiramento
free -h free -m -s 2 # Atualiza a cada 2 segundos
nproc lscpu | grep -E "Model name|^CPU\(s\)"
lsblk lsblk -f # Com sistema de arquivos e UUID sudo fdisk -l
sudo mount /dev/sdb1 /mnt/usb sudo umount /mnt/usb montar | coluna -t # Montado cat /etc/fstab # Monta automaticamente na inicialização
vmstat 1 10
iostat -x 1 5
sudo dmesg -T | tail -50 sudo dmesg -T | grep -i "processo morto" # Quem recebeu OOM?
env | sort printenv HOME echo $PATH | tr ":" "\n"
export JAVA_HOME=/usr/lib/jvm/java-17 export PATH="$HOME/.local/bin:$PATH" echo 'export EDITOR=vim' >> ~/.bashrc && source ~/.bashrc
alias ll="ls -alF" alias gs="git status" unalias ll alias # lista
history | grep ssh !105 sudo !! história -c # Limpar
sudo apt update && sudo apt upgrade sudo apt install htop apt search nginx apt show nginx sudo apt remove --purge pkg && sudo apt autoremove
| update | Atualizar índice de origem de software |
| upgrade | Atualizar pacote instalado |
| install / remove | Instalar/desinstalar |
| search / show | Pesquisa / Detalhes |
| autoremove | Limpar dependências não é mais necessária |
| list --installed | Lista instalada |
sudo dnf install -y git sudo dnf update dnf search nginx sudo yum install epel-release # Sistema antigo
sudo pacman -Syu sudo pacman -S neovim pacman -Ss keyword sudo pacman -Rns pkg
brew install jq brew upgrade brew list brew search ripgrep
sudo snap install code --classic snap list
sudo dpkg -i app.deb sudo apt -f install dpkg -l | grep nginx dpkg -L nginx #Quais arquivos são empacotados?
sudo shutdown -h now sudo reboot sudo shutdown -r +10 "Reiniciar manutenção após 10 minutos" sudo shutdown -c # Cancelar
date date "+%Y-%m-%d %H:%M:%S" date -d "yesterday" +%F data +%s # carimbo de data/hora date -d @1700000000 # Converte o carimbo de data/hora em data
timedatectl sudo timedatectl set-timezone Asia/Shanghai timedatectl list-timezones | grep Asia
cal cal 2026 cal -3 # um mês antes e depois
lsmod | grep nvidia sudo modprobe br_netfilter
lspci | grep -i vga lsusb
ulimit -n ulimit -n 65535 # Sessão atual cat /proc/sys/fs/file-max
chsh -s $(which zsh) echo $SHELL
source ~/.bashrc . ~/.zshrc # Sinônimo
#!/usr/bin/env bash set -euo pipefail # Parada em caso de erro, erro de variável indefinida, transmissão de erro de pipe for f in *.log; do echo "processo $f" done
man tar man 5 crontab # Seção 5: Formato de arquivo tar --help | less tldr tar # Versão de amostra da comunidade (requer instalação)
Um pequeno sistema de arquivos e um interpretador de shell em memória: aceita ls / cd / cat / grep / sed / awk / find / chmod / tar e mais de 60 comandos, com pipes, redirecionamentos e curingas; 8 níveis vão de “criar uma árvore de diretórios” a “estatísticas com pipes”. Não acessa a rede nem toca nos seus arquivos reais. A prática de comandos Git está emReferência de comandos do Git.