Linux — Folha de Dicas Completo· Edvandro Amancio

01

Fundamentos & Estrutura do Sistema

FHS · Boot · Distros · CLI básica · Ajuda

Básico

Hierarquia de Diretórios (FHS)

Diretório	Função
/	Root — raiz de todo o sistema de arquivos
/bin	Binários essenciais (ls, cp, mv, bash) — disponíveis antes do mount
/sbin	Binários de administração do sistema (fdisk, ip, mount, fsck)
/etc	Configurações do sistema — texto editável
/home	Diretórios pessoais dos usuários
/root	Home do superusuário root
/var	Dados variáveis: logs, spool, cache, PID
/tmp	Temporários — limpo no boot (sticky bit)
/usr	Programas, libs e docs de usuário
/usr/local	Software instalado manualmente pelo admin
/lib /lib64	Bibliotecas compartilhadas (.so)
/proc	Virtual FS — estado do kernel e processos
/sys	Virtual FS — dispositivos e kernel (sysfs)
/dev	Arquivos de dispositivo (block/char)
/mnt /media	Pontos de montagem temporários
/opt	Software opcional de terceiros
/boot	Kernel, initrd, GRUB
/run	Runtime data — PIDs, sockets (tmpfs)
/srv	Dados de serviços (HTTP, FTP)

Processo de Boot Linux

1. BIOS/UEFI — POST, identifica hardware, carrega bootloader do MBR/EFI
2. GRUB2 — bootloader; carrega kernel (/boot/vmlinuz-*) e initrd
3. initramfs — FS temporário em RAM; drivers iniciais; monta root real
4. Kernel — descomprime, inicializa hardware, monta root, inicia init
5. systemd (PID 1) — gerencia targets, units, dependências de serviços
6. Targets — sysinit → basic → multi-user → graphical
7. Login — Getty, PAM, shell do usuário

Arquivo/Cmd	Função
/boot/grub/grub.cfg	Config do GRUB2
grub-update / grub2-mkconfig	Regenerar GRUB config
/etc/default/grub	Parâmetros do kernel via GRUB
dmesg	Log do kernel no boot
systemctl get-default	Target padrão
systemctl set-default multi-user.target	Setar target padrão

Navegação & Comandos Essenciais

bash — ubuntu-desktop

$ pwd # Print Working Directory

$ ls -lah # lista com detalhes, hidden, human-readable

$ ls -lrt # ordenado por tempo, reverso (mais novo por último)

$ cd /var/log # muda de diretório

$ cd ~ # volta ao home

$ cd - # volta ao diretório anterior

$ cd .. # sobe um nível

$ mkdir -p dir1/dir2/dir3 # cria árvore de dirs

$ rmdir dir_vazio # remove dir vazio

$ cp -r src/ dst/ # copia recursivo

$ mv arquivo.txt /tmp/ # move ou renomeia

$ rm -rf dir/ # remove recursivo forçado ⚠

$ touch arquivo.txt # cria arquivo ou atualiza timestamp

$ file binário # identifica tipo do arquivo

$ stat arquivo # metadados completos (inode, timestamps)

$ ln -s alvo link # symlink simbólico

$ ln alvo link # hard link

Ajuda & Documentação

Comando	Uso
man ls	Manual completo do comando
man -k keyword	Busca man pages por palavra-chave (= apropos)
man 5 passwd	Man da seção 5 (formatos de arquivo)
info bash	Documentação GNU (mais detalhada que man)
ls --help	Ajuda rápida do comando
whatis ls	Descrição de uma linha
type ls	Identifica tipo: builtin, alias, function, file
which python3	Caminho absoluto do binário
whereis bash	Binário + man + source
tldr curl	Exemplos práticos simplificados (requer instalação)

Seções do Manual

Seção	Conteúdo
1	Comandos de usuário
2	System calls (syscalls)
3	Funções de biblioteca C
4	Arquivos de dispositivo (/dev)
5	Formatos de arquivo (/etc/passwd)
6	Jogos
7	Miscelânea (protocolos, conceitos)
8	Comandos de administração

Visualização & Manipulação de Texto

bash

$ cat arquivo # exibe conteúdo

$ cat -n arquivo # com numeração de linhas

$ less arquivo # paginador (q=quit, /=busca)

$ more arquivo # paginador simples

$ head -20 arquivo # primeiras 20 linhas

$ tail -20 arquivo # últimas 20 linhas

$ tail -f /var/log/syslog # segue log em tempo real

$ grep "error" arquivo # busca padrão

$ grep -rni "passwd" /etc/ # recursivo, no nº linha, case-insensitive

$ wc -l arquivo # conta linhas

$ wc -w -c arquivo # palavras, bytes

$ sort -k2 -n arquivo # ordena por coluna 2 numérica

$ sort -u arquivo # ordena e remove duplicatas

$ uniq -c arquivo # conta ocorrências consecutivas

$ tr 'a-z' 'A-Z' # converte caracteres

$ cut -d: -f1 /etc/passwd # extrai campo 1, delimitador :

$ diff arq1 arq2 # diferenças entre arquivos

$ diff -u arq1 arq2 # formato unified (para patches)

Busca de Arquivos

bash

# find — busca real no filesystem

$ find / -name "*.conf" 2/dev/null

$ find /home -type f -size +10M

$ find /tmp -mtime -1 # modificados última 24h

$ find / -perm -4000 -type f # SUID files

$ find / -user root -perm -4000 # SUID owned by root

$ find . -name "*.log" -exec rm {} \;

$ find . -name "*.py" -exec grep -l "import" {} +

# locate — índice rápido (requer updatedb)

$ locate passwd

$ updatedb # atualiza banco do locate

# which/whereis

$ which python3

$ whereis bash

02

Sistema de Arquivos & Redirecionamento

Pipes · Redirecionamento · Compressão · Inodes

Básico

Redirecionamento & Pipes

Operador	Função	Exemplo
>	Redireciona stdout (sobrescreve)	ls > out.txt
>>	Redireciona stdout (append)	echo "x" >> log
<	Redireciona stdin	sort < lista.txt
2>	Redireciona stderr	cmd 2> err.txt
2>&1	stderr para stdout	cmd >out 2>&1
>/dev/null	Descarta stdout	cmd >/dev/null
2>/dev/null	Descarta stderr	cmd 2>/dev/null
&>	Redireciona stdout+stderr (bash)	cmd &> all.log
\|	Pipe — stdout p/ stdin do próximo	ps aux \| grep nginx
tee	Divide saída (arquivo + stdout)	cmd \| tee out.txt
<<EOF	Here document	cat <<EOF ... EOF
<<<	Here string	base64 <<< "texto"

# Pipeline clássico

$ cat /etc/passwd | cut -d: -f1 | sort | uniq

$ ps aux | grep -v grep | awk '{print $2, $11}'

$ find . -name "*.log" | xargs grep "ERROR"

Compressão & Arquivamento

Comando	Ação
tar -czf arq.tar.gz dir/	Comprime com gzip
tar -cjf arq.tar.bz2 dir/	Comprime com bzip2
tar -cJf arq.tar.xz dir/	Comprime com xz (melhor ratio)
tar -xzf arq.tar.gz	Extrai tar.gz
tar -xzf arq.tar.gz -C /dest/	Extrai em diretório específico
tar -tzf arq.tar.gz	Lista conteúdo sem extrair
gzip -k arquivo	Comprime mantendo original
gunzip arquivo.gz	Descomprime gzip
zcat arquivo.gz	Lê gzip sem descomprimir
zip -r arq.zip dir/	Cria ZIP recursivo
unzip arq.zip -d /dest/	Extrai ZIP
7z a arq.7z dir/	Comprime com 7-zip
rsync -avz src/ dst/	Sync com compressão

💡 Dica Flags tar: c=create, x=extract, t=list, z=gzip, j=bzip2, J=xz, v=verbose, f=file

Inodes, Links & Sistema de Arquivos

Inode — estrutura de metadados: permissões, owner, timestamps, ponteiros de bloco (não nome)
Hard Link — mesmo inode; delete original = arquivo persiste; não cruza filesystem; não funciona em dirs
Symlink (Soft) — aponta para path; quebra se original deletado; cruza FS; funciona em dirs
Tipo de arquivo em ls -l: -=regular, d=dir, l=link, b=block dev, c=char dev, p=pipe, s=socket

$ ls -i arquivo # mostra inode number

$ stat arquivo # todos os metadados

$ df -h # espaço em disco (human-readable)

$ df -i # uso de inodes

$ du -sh /var/log/ # tamanho de diretório

$ du -h --max-depth=1 /

$ lsblk # dispositivos de bloco

$ blkid # UUID e tipo dos dispositivos

$ mount # mostra pontos de montagem

$ mount /dev/sdb1 /mnt/data

$ umount /mnt/data

sed, awk & Processamento de Texto Avançado

# sed — stream editor

$ sed 's/foo/bar/g' arquivo # substitui foo por bar

$ sed -i 's/foo/bar/g' arquivo # substitui in-place

$ sed -n '10,20p' arquivo # imprime linhas 10-20

$ sed '/^#/d' arquivo # remove linhas com #

$ sed 's/^/ /' arquivo # adiciona espaços no início

# awk — processamento por campo

$ awk '{print $1}' arquivo # imprime col 1

$ awk -F: '{print $1,$3}' /etc/passwd

$ awk '$3 > 1000 {print $1}' /etc/passwd

$ awk '{sum+=$1} END{print sum}' números.txt

$ awk 'NR%2==0' arquivo # linhas pares

# xargs — constrói comandos a partir do stdin

$ cat ips.txt | xargs -I{} ping -c1 {}

$ find . -name "*.log" | xargs -P4 gzip # paralelo

03

Permissões & Ownership

chmod · chown · SUID · SGID · Sticky · ACL · umask

Básico

Anatomia das Permissões

EXEMPLO: -rwxr-xr--

-

r

w

x

r

-

x

r

-

type | owner | group | others

Permissão	Arquivo	Diretório	Octal
r (read)	Lê conteúdo	Lista arquivos (ls)	4
w (write)	Modifica conteúdo	Cria/deleta arquivos	2
x (execute)	Executa binário	Entra no dir (cd)	1
- (none)	Sem permissão	Sem permissão	0

TABELA OCTAL COMPLETA

0 = ---

1 = --x

2 = -w-

3 = -wx

4 = r--

5 = r-x

6 = rw-

7 = rwx

chmod, chown & chgrp

# chmod — muda permissões

$ chmod 755 script.sh # rwxr-xr-x

$ chmod 644 arquivo.txt # rw-r--r--

$ chmod 600 chave.pem # rw------- (SSH key)

$ chmod u+x script # add execute p/ owner

$ chmod go-w arquivo # remove write de group+others

$ chmod a+r arquivo # read para todos

$ chmod -R 755 dir/ # recursivo

# chown — muda dono

$ chown user:group arquivo

$ chown -R www-data:www-data /var/www/

$ chown :grupo arquivo # só muda grupo

# umask — permissão padrão

$ umask # exibe umask atual (ex: 0022)

$ umask 027 # seta: arquivo=640, dir=750

# arquivo padrão = 666 - umask = 644 (com 022)

# dir padrão = 777 - umask = 755 (com 022)

Bits Especiais: SUID, SGID & Sticky Bit

Bit	Octal	Arquivo	Diretório	Identificação
SUID	4000	Executa como owner (root)	N/A	s no lugar de x do owner
SGID	2000	Executa como grupo	Herda grupo do dir	s no lugar de x do group
Sticky	1000	N/A (legado)	Só owner deleta seus arquivos	t no lugar de x dos outros

$ chmod 4755 programa # SUID + 755

$ chmod 2755 dir/ # SGID em diretório

$ chmod 1777 /tmp # Sticky + rwxrwxrwx

$ ls -la /usr/bin/passwd

-rwsr-xr-x 1 root root ... /usr/bin/passwd

# S maiúsculo = SUID sem execute bit (inoperante)

$ find / -perm -u=s -type f 2>/dev/null # achar SUID

⚠ Risco de Segurança SUID em binários customizados é vetor de escalada de privilégios. Auditoria regular com find SUID é boa prática.

ACL — Access Control List

Comando	Função
getfacl arquivo	Exibe ACL atual
setfacl -m u:bob:rwx arquivo	Adiciona permissão ao usuário bob
setfacl -m g:devs:rx arquivo	Adiciona permissão ao grupo devs
setfacl -R -m u:bob:rx dir/	ACL recursiva em diretório
setfacl -x u:bob arquivo	Remove ACL do usuário
setfacl -b arquivo	Remove todas as ACLs
setfacl -d -m u:bob:rwx dir/	ACL padrão (herdada por novos arquivos)

ℹ Info ACL requer suporte do filesystem (ext4, xfs, btrfs). O + ao final das permissões em ls -l indica ACL ativa.

04

Processos & Gerenciamento de Jobs

ps · top · htop · kill · signals · nice · jobs · cron

Intermediário

Monitoramento de Processos

$ ps aux # todos os processos (BSD style)

$ ps -ef # todos os processos (POSIX style)

$ ps -ef --forest # árvore de processos

$ ps aux | grep nginx

$ ps -p 1234 -o pid,ppid,cmd,%cpu,%mem

$ top # monitor interativo (q=quit, k=kill)

$ top -b -n 1 -o %CPU # snapshot ordenado por CPU

$ htop # top melhorado (requer instalação)

$ pgrep -l nginx # encontra PID por nome

$ pgrep -u www-data # processos de usuário

$ pidof nginx # PIDs do processo

$ lsof -p 1234 # arquivos abertos por PID

$ lsof -i :80 # processos usando porta 80

$ lsof -u root # arquivos abertos por usuário

$ pstree # árvore visual de processos

Sinais & kill

Sinal	Número	Comportamento
SIGHUP	1	Hangup — relê config sem matar
SIGINT	2	Interrupt — Ctrl+C
SIGQUIT	3	Quit — Ctrl+\ — gera core dump
SIGKILL	9	Kill imediato — não pode ser ignorado
SIGTERM	15	Terminate — graceful (padrão)
SIGSTOP	19	Pause — não pode ser ignorado
SIGCONT	18	Continue processo pausado
SIGUSR1/2	10/12	Definidos pelo usuário
SIGCHLD	17	Filho terminou

$ kill 1234 # SIGTERM (15) default

$ kill -9 1234 # SIGKILL — força

$ kill -HUP 1234 # reload config

$ killall nginx # mata por nome

$ pkill -9 -u bob # mata processos do user

Jobs, Background & nice

# Controle de jobs

$ sleep 100 & # executa em background

$ jobs # lista jobs da sessão

$ fg %1 # traz job 1 para foreground

$ bg %1 # retoma job 1 em background

# Ctrl+Z — suspende processo atual

# nice — prioridade de CPU (-20=alta, 19=baixa)

$ nice -n 10 tar -czf backup.tar.gz /

$ renice -n 5 -p 1234 # muda prioridade

# nohup — executa imune a hangup

$ nohup ./script.sh >out.log 2>&1 &

# disown — desacopla job do shell

$ disown -h %1

Agendamento: cron & systemd timers

# Formato crontab

* * * * * comando

min(0-59) hora(0-23) dia(1-31) mês(1-12) dow(0-7)

Expressão	Significado
0 2 * * *	Todo dia às 2h
/5 * * *	A cada 5 minutos
0 9-17 * * 1-5	9h-17h dias úteis
0 0 1 * *	Primeiro dia do mês
@reboot	Ao iniciar o sistema
@daily	Uma vez por dia (0 0 * * *)
@weekly	Uma vez por semana
@monthly	Uma vez por mês

$ crontab -e # edita crontab do usuário

$ crontab -l # lista crontab

$ crontab -r # remove crontab

$ crontab -u bob -l # crontab de outro user

05

Rede & Conectividade

ip · ss · SSH · curl · nmap · firewall

Intermediário

Configuração de Rede (iproute2)

# Interfaces

$ ip addr show # (ip a) — endereços

$ ip link show # (ip l) — interfaces

$ ip link set eth0 up

$ ip addr add 192.168.1.10/24 dev eth0

$ ip addr del 192.168.1.10/24 dev eth0

# Rotas

$ ip route show # (ip r) — tabela de rotas

$ ip route add default via 192.168.1.1

$ ip route add 10.0.0.0/8 via 192.168.1.1

$ ip route get 8.8.8.8 # qual rota p/ destino

# DNS

$ cat /etc/resolv.conf

$ resolvectl status # systemd-resolved

$ dig google.com +short

$ dig @8.8.8.8 google.com MX

$ nslookup google.com

$ host google.com

Sockets & Portas — ss (iproute2)

# ss — iproute2, substitui netstat/route

$ ss -tulnp # TCP+UDP, listen, num, pid

$ ss -t state established

$ ss -s # sumário de estatísticas

$ ss -tlnp sport = :22

$ ss -xnp # Unix domain sockets

# Conectividade

$ ping -c4 8.8.8.8

$ traceroute google.com

$ mtr google.com # ping+traceroute interativo

$ nc -zv host 80 # testa porta

$ nc -lvp 4444 # listener (pentest)

$ telnet host 25 # teste básico de porta

SSH — Secure Shell

# Conexão básica

$ ssh user@host

$ ssh -p 2222 user@host

$ ssh -i ~/.ssh/chave.pem user@host

# Geração de chaves

$ ssh-keygen -t ed25519 -C "[email protected]"

$ ssh-keygen -t rsa -b 4096

$ ssh-copy-id user@host # copia pub key

# Tunneling

$ ssh -L 8080:localhost:80 user@host # local forward

$ ssh -R 9090:localhost:9090 user@host # remote forward

$ ssh -D 1080 user@host # SOCKS proxy

$ ssh -N -f -L 8080:localhost:80 user@host

# SCP & rsync

$ scp arquivo.txt user@host:/tmp/

$ scp -r dir/ user@host:~/

$ rsync -avz --progress src/ user@host:dst/

curl, wget & nmap

# curl

$ curl https://api.example.com

$ curl -o arquivo.html https://site.com

$ curl -I https://site.com # headers apenas

$ curl -X POST -H "Content-Type: application/json" -d '{"k":"v"}' URL

$ curl -u user:pass https://api.com

$ curl -k https://self-signed.local # ignora cert

# wget

$ wget https://site.com/arquivo

$ wget -r -np https://site.com # recursivo

# nmap

$ nmap 192.168.1.1 # scan básico

$ nmap -sV -sC 192.168.1.0/24

$ nmap -A -T4 host # agressivo

$ nmap -p- host # todas as portas

$ nmap -sU -p 161 host # UDP scan

06

Usuários, Grupos & sudo

useradd · passwd · groups · sudoers · PAM · /etc/passwd

Intermediário

Gerenciamento de Usuários & Grupos

# Criar/modificar usuários

$ useradd -m -s /bin/bash bob # cria com home e shell

$ useradd -r -s /sbin/nologin svc # service account

$ passwd bob # define senha

$ usermod -aG sudo bob # adiciona ao grupo sudo

$ usermod -s /bin/bash bob # muda shell

$ usermod -L bob # bloqueia conta

$ usermod -U bob # desbloqueia conta

$ userdel -r bob # remove com home

# Grupos

$ groupadd devs

$ groupdel devs

$ gpasswd -a bob devs # adiciona ao grupo

$ gpasswd -d bob devs # remove do grupo

$ groups bob # lista grupos do user

$ id bob # UID, GID, grupos

$ who # usuários logados

$ w # usuários + atividade

$ last # histórico de logins

$ lastfail # logins falhados

sudo & /etc/sudoers

Regra Sudoers	Significa
bob ALL=(ALL) ALL	bob pode rodar tudo como qualquer user
bob ALL=(ALL) NOPASSWD: ALL	bob sudo sem senha
%sudo ALL=(ALL) ALL	Grupo sudo pode tudo
bob ALL=(root) /bin/systemctl	Só systemctl como root
!command	Proíbe o comando específico
Defaults requiretty	Exige TTY real para sudo
Defaults timestamp_timeout=0	Sempre pede senha

$ visudo # edita sudoers com validação

$ sudo -l # lista permissões sudo

$ sudo -u bob whoami # executa como bob

$ sudo -i # shell de root interativo

$ sudo -s # shell de root (env atual)

$ su - bob # troca para user bob

Arquivos de Configuração de Usuário

Arquivo	Formato / Conteúdo
/etc/passwd	user:x:UID:GID:GECOS:home:shell
/etc/shadow	user:hash:lastchg:min:max:warn:inactive:expire
/etc/group	group:x:GID:members
/etc/gshadow	Senhas de grupo hasheadas
/etc/sudoers	Regras de elevação de privilégio
/etc/sudoers.d/	Fragmentos de sudoers
/etc/login.defs	Configurações padrão de conta
/etc/skel/	Arquivos copiados para novo home
/etc/pam.d/	Regras PAM por serviço
/etc/security/	Limites PAM, hosts permitidos

ℹ /etc/shadow hash formats $1$=MD5, $5$=SHA-256, $6$=SHA-512, $y$=yescrypt, $2b$=bcrypt

PAM — Pluggable Authentication Modules

auth — verifica identidade do usuário (senha, biometria)
account — verifica restrições de conta (expiração, horário)
password — muda a senha conforme política
session — configura ambiente de sessão (montagem de home, logs)

Controle	Comportamento
required	Falha não interrompe, mas resultado final falha
requisite	Falha interrompe imediatamente
sufficient	Sucesso encerra (se nenhum required falhou antes)
optional	Resultado não afeta autenticação

# Políticas de senha

$ chage -l bob # info de expiração

$ chage -M 90 -m 7 -W 14 bob

$ passwd -e bob # força mudança na próx. login

$ faillock --user bob # falhas de login

$ faillock --user bob --reset # desbloqueia

07

Shell Scripting & Bash

variáveis · loops · condicionais · funções · arrays · regex

Intermediário

Variáveis, Expansão & Especiais

#!/bin/bash

NAME="Mariana" # sem espaços!

readonly PI=3.14

export PATH="$PATH:/opt/bin"

# Variáveis especiais

$0 # nome do script

$1-$9 # argumentos posicionais

$@ # todos os argumentos (array)

$* # todos os argumentos (string)

$# # número de argumentos

$? # exit code do último comando

$$ # PID do script

$! # PID do último background job

# Expansão de parâmetro

${VAR:-default} # valor ou default

${VAR:=default} # define e retorna default

${#VAR} # comprimento da string

${VAR^^} # maiúsculas

${VAR,,} # minúsculas

${VAR/foo/bar} # substitui primeira ocorrência

${VAR//foo/bar} # substitui todas

${VAR#prefix} # remove prefixo

${VAR%suffix} # remove sufixo

Condicionais & Loops

# if / elif / else

if [[ $USER == "root" ]]; then

echo "É root"

elif [[ $UID -gt 1000 ]]; then

echo "Usuário comum"

fi

# Operadores [[...]]

# -eq -ne -lt -le -gt -ge (numérico)

# == != < > (string) | -z (vazia) -n (não-vazia)

# -f (arquivo) -d (dir) -e (existe) -r -w -x

# for loop

for i in {1..10}; do

echo "Item $i"

done

for file in *.log; do

gzip "$file"

done

# while loop

while read -r line; do

echo "$line"

done < arquivo.txt

# case

case $1 in

start) echo "starting" ;;

stop) echo "stopping" ;;

*) echo "unknown" ;;

esac

Funções, Arrays & Tratamento de Erros

# Funções

log() {

local msg="$1"

echo "[$(date)] $msg" | tee -a /var/log/script.log

return 0

}

log "Script started"

# Arrays

arr=("a" "b" "c")

echo ${arr[0]} # primeiro elemento

echo ${arr[@]} # todos

echo ${#arr[@]} # tamanho

arr+=("d") # append

unset arr[1] # remove elemento

# Tratamento de erros robusto

set -euo pipefail # exit on error, unbound, pipe

trap 'echo "ERRO na linha $LINENO"' ERR

trap 'rm -f /tmp/lockfile' EXIT

Regex, Globbing & Substituição de Processo

Padrão	Significado
.	Qualquer caractere
*	Zero ou mais do anterior
+	Um ou mais do anterior
?	Zero ou um do anterior
^	Início da linha
$	Fim da linha
[abc]	Classe de caracteres
[^abc]	Negação de classe
\d \w \s	Dígito, word char, espaço (ERE)
{n,m}	Repetições entre n e m
(foo\|bar)	Alternação / grupo

$ grep -E '^[0-9]{1,3}\.' ips.txt

$ grep -P '\d{3}-\d{4}' contatos

# Globbing bash

* # qualquer string

? # qualquer char único

[0-9] # classe de char

** # (globstar) recursivo

# shopt -s globstar — ativa **

# Process substitution

$ diff <(sort a) <(sort b)

$ comm <(sort a) <(sort b)

08

Storage, LVM & RAID

fdisk · parted · LVM · RAID · mkfs · fstab · swap

Avançado

Particionamento & Filesystems

# fdisk (MBR) / gdisk (GPT)

$ fdisk -l # lista discos e partições

$ fdisk /dev/sdb # particionar interativo

$ gdisk /dev/sdb # GPT partitioning

$ parted /dev/sdb mklabel gpt

$ parted /dev/sdb mkpart primary ext4 1MiB 50GiB

# Criar filesystems

$ mkfs.ext4 /dev/sdb1

$ mkfs.xfs /dev/sdb2

$ mkfs.btrfs /dev/sdb3

$ mkswap /dev/sdb4

$ swapon /dev/sdb4

# /etc/fstab

# UUID=... /mnt/data ext4 defaults 0 2

$ blkid /dev/sdb1 # obter UUID

$ mount -a # monta tudo do fstab

LVM — Logical Volume Manager

Componente	Descrição
PV (Physical Volume)	Disco ou partição física inicializada p/ LVM
VG (Volume Group)	Pool de PVs — abstração de espaço total
LV (Logical Volume)	Volume virtual que se torna /dev/vg/lv

# Criar LVM

$ pvcreate /dev/sdb

$ vgcreate myvg /dev/sdb

$ lvcreate -L 20G -n data myvg

$ mkfs.ext4 /dev/myvg/data

# Expandir LV

$ lvextend -L +10G /dev/myvg/data

$ resize2fs /dev/myvg/data # ext4

$ xfs_growfs /mnt/data # xfs

# Snapshot LVM

$ lvcreate -L 5G -s -n snap /dev/myvg/data

# Informações

$ pvs / vgs / lvs

$ pvdisplay / vgdisplay / lvdisplay

RAID (mdadm) & Backup

Nível	Mínimo	Redundância	Performance
RAID 0	2	Nenhuma — striping	↑↑ R+W
RAID 1	2	Espelho completo	↑ R, = W
RAID 5	3	1 disco — paridade distribuída	↑ R, ↓ W
RAID 6	4	2 discos — paridade dupla	↑ R, ↓↓ W
RAID 10	4	Mirror + Stripe	↑↑ R+W

$ mdadm --create /dev/md0 --level=5 --raid-devices=3 /dev/sd{b,c,d}

$ mdadm --detail /dev/md0

$ cat /proc/mdstat # status RAID

# rsync backup

$ rsync -avz --delete /data/ user@backup:/data/

$ rsync --link-dest=../prev /src/ /bkp/today/

Monitoramento de Storage

$ iostat -xz 1 # I/O por dispositivo (1s)

$ iotop # top por I/O

$ vmstat 1 # memória, swap, I/O

$ smartctl -a /dev/sda # health do disco

$ smartctl -t short /dev/sda

$ hdparm -I /dev/sda # info disco

$ e2fsck -f /dev/sdb1 # verifica ext4

$ tune2fs -l /dev/sdb1 # info ext4

$ xfs_repair /dev/sdc1 # verifica xfs

09

Serviços & systemd

units · targets · journald · service files · timers

Avançado

systemctl — Gerenciamento de Serviços

# Controle de serviços

$ systemctl start nginx

$ systemctl stop nginx

$ systemctl restart nginx

$ systemctl reload nginx # sem downtime

$ systemctl status nginx

# Persistência no boot

$ systemctl enable nginx

$ systemctl disable nginx

$ systemctl enable --now nginx

$ systemctl mask nginx # impede start

$ systemctl unmask nginx

# Listagem

$ systemctl list-units --type=service

$ systemctl list-units --failed

$ systemctl list-unit-files

$ systemctl cat nginx # mostra unit file

$ systemctl edit nginx # override config

$ systemctl daemon-reload # recarrega unit files

Criando Unit Files Customizados

# /etc/systemd/system/meuapp.service

[Unit]

Description=Meu Aplicativo

After=network.target

Requires=postgresql.service

[Service]

Type=simple

User=appuser

WorkingDirectory=/opt/meuapp

ExecStart=/opt/meuapp/bin/app --config /etc/meuapp.conf

ExecReload=/bin/kill -HUP $MAINPID

Restart=on-failure

RestartSec=5s

Environment="NODE_ENV=production"

StandardOutput=journal

StandardError=journal

# Security hardening

NoNewPrivileges=yes

ProtectSystem=strict

PrivateTmp=yes

[Install]

WantedBy=multi-user.target

journald & Logs

$ journalctl # todos os logs

$ journalctl -u nginx # logs do serviço

$ journalctl -f # follow (tail -f)

$ journalctl -n 50 # últimas 50 linhas

$ journalctl -p err # nível erro ou acima

$ journalctl --since "2024-01-01" --until "today"

$ journalctl --disk-usage

$ journalctl --vacuum-size=100M

# Arquivos de log tradicionais

$ tail -f /var/log/syslog

$ tail -f /var/log/auth.log

$ grep "Failed password" /var/log/auth.log

$ zgrep "ERROR" /var/log/nginx/error.log.gz

Performance & Diagnóstico

Comando	Função
top / htop	CPU, memória, processos em tempo real
vmstat 1	CPU, swap, I/O, memória (por segundo)
iostat -xz 1	I/O de disco por dispositivo
free -h	Uso de RAM e swap
uptime	Load average (1m, 5m, 15m)
sar -u 1 10	CPU histórico (sysstat)
sar -r 1 10	Memória histórica
sar -n DEV 1 5	I/O de rede
perf stat cmd	Contadores hardware do processo
strace -p PID	System calls em tempo real
ltrace cmd	Library calls
lsof -i	Conexões abertas
iftop -n	Tráfego de rede em tempo real
nethogs	Tráfego por processo

10

Segurança & Hardening

firewall · SELinux · AppArmor · auditd · fail2ban · OpenSSL

Avançado

Firewall: iptables & nftables

# iptables

$ iptables -L -n -v # lista regras

$ iptables -A INPUT -p tcp --dport 22 -j ACCEPT

$ iptables -A INPUT -s 10.0.0.0/8 -j ACCEPT

$ iptables -P INPUT DROP # policy padrão

$ iptables -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT

$ iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE

$ iptables-save > /etc/iptables/rules.v4

# ufw (Ubuntu frontend)

$ ufw enable

$ ufw allow 22/tcp

$ ufw allow from 192.168.1.0/24 to any port 3306

$ ufw deny 23

$ ufw status verbose

$ ufw delete allow 22/tcp

SELinux & AppArmor (MAC)

Aspecto	SELinux	AppArmor
Distros	RHEL, Fedora, CentOS	Ubuntu, Debian, SUSE
Modelo	Label-based (contextos)	Path-based (profiles)
Complexidade	Alta	Média
Modo enforce	enforcing/permissive/disabled	enforce/complain/disabled

# SELinux

$ getenforce # modo atual

$ setenforce 0 # permissive (temporário)

$ sestatus # status detalhado

$ ls -Z arquivo # contexto SELinux

$ restorecon -Rv /var/www/

$ audit2why < /var/log/audit/audit.log

# AppArmor

$ aa-status

$ aa-enforce /etc/apparmor.d/usr.sbin.nginx

$ aa-complain /etc/apparmor.d/usr.sbin.nginx

$ aa-logprof # analisa violações e sugere regras

auditd, fail2ban & Hardening

# auditd — auditoria de sistema

$ auditctl -l # lista regras

$ auditctl -w /etc/passwd -p rwxa -k passwd_watch

$ ausearch -k passwd_watch

$ aureport --auth

# fail2ban

$ fail2ban-client status

$ fail2ban-client status sshd

$ fail2ban-client set sshd unbanip 1.2.3.4

# Hardening SSH (/etc/ssh/sshd_config)

PermitRootLogin no

PasswordAuthentication no

MaxAuthTries 3

AllowUsers deploy bob

Protocol 2

Port 2222

Criptografia & OpenSSL

# Hashing

$ sha256sum arquivo

$ md5sum arquivo

$ openssl dgst -sha256 arquivo

# Certificados

$ openssl req -new -x509 -nodes -days 365 -keyout server.key -out server.crt

$ openssl x509 -in cert.crt -text -noout

$ openssl s_client -connect host:443

$ openssl verify -CAfile ca.crt server.crt

# Encriptação simétrica

$ openssl enc -aes-256-cbc -in plain.txt -out enc.bin

$ openssl enc -d -aes-256-cbc -in enc.bin -out dec.txt

# GPG

$ gpg --gen-key

$ gpg -e -r [email protected] arquivo

$ gpg -d arquivo.gpg

11

Kernel & Internals

modules · sysctl · /proc · namespaces · cgroups · syscalls

Expert

Módulos do Kernel

$ lsmod # módulos carregados

$ modinfo ext4 # info do módulo

$ modprobe overlay # carrega módulo

$ modprobe -r overlay # remove módulo

$ insmod modulo.ko # carrega .ko diretamente

$ rmmod modulo

$ depmod -a # atualiza deps

# Persistente: /etc/modules-load.d/

# Blacklist: /etc/modprobe.d/blacklist.conf

Parâmetros /proc/sys (sysctl)

Parâmetro	Função
net.ipv4.ip_forward=1	Habilita roteamento IP
net.ipv4.tcp_syncookies=1	Proteção SYN flood
kernel.randomize_va_space=2	ASLR — randomização de memória
fs.suid_dumpable=0	Desabilita core dump SUID
net.ipv4.conf.all.rp_filter=1	Source validation
vm.swappiness=10	Preferência por uso de swap
kernel.dmesg_restrict=1	Restringe dmesg a root

$ sysctl -a # lista todos

$ sysctl -w net.ipv4.ip_forward=1

$ sysctl -p # aplica /etc/sysctl.conf

Namespaces, cgroups & Containers

Namespace	Isola	Flag
mnt	Pontos de montagem	CLONE_NEWNS
pid	Espaço de PIDs	CLONE_NEWPID
net	Stack de rede	CLONE_NEWNET
uts	Hostname	CLONE_NEWUTS
ipc	IPC (semáforos, filas)	CLONE_NEWIPC
user	UID/GID mapping	CLONE_NEWUSER
cgroup	Visão de cgroups	CLONE_NEWCGROUP
time	Clock namespaces	CLONE_NEWTIME

# cgroups v2

$ ls /sys/fs/cgroup/

$ cat /sys/fs/cgroup/memory/docker/memory.limit_in_bytes

$ systemd-cgtop # uso de cgroup por serviço

# Namespaces do processo

$ ls -la /proc/$$/ns/

$ unshare --pid --fork bash # novo PID ns

$ nsenter -t PID --pid --net bash

ℹ Containers = namespaces + cgroups Docker/Podman combinam namespaces (isolamento) + cgroups (limites de recurso) + seccomp + capabilities para criar containers.

Procfs — /proc & /sys

Arquivo	Conteúdo
/proc/cpuinfo	Detalhes de cada core CPU
/proc/meminfo	Uso de memória RAM/swap
/proc/loadavg	Load average + processos
/proc/uptime	Tempo ligado + idle
/proc/net/tcp	Conexões TCP (hex)
/proc/net/if_inet6	Interfaces IPv6
/proc/$PID/maps	Mapa de memória do processo
/proc/$PID/fd/	File descriptors abertos
/proc/$PID/cmdline	Linha de comando do processo
/proc/$PID/status	Estado e uso de memória
/proc/sys/kernel/	Parâmetros do kernel
/sys/class/net/	Interfaces de rede
/sys/block/sda/	Parâmetros do disco

Linux Capabilities & seccomp

Capability	Permite
CAP_NET_ADMIN	Config de rede, iptables
CAP_NET_BIND_SERVICE	Bind em porta <1024
CAP_SYS_ADMIN	Mount, namespace, ptrace
CAP_SYS_PTRACE	Trace de processos
CAP_SETUID	Muda UID arbitrariamente
CAP_DAC_OVERRIDE	Bypassa DAC (rwx)
CAP_CHOWN	Muda ownership
CAP_KILL	Envia sinal a qualquer processo

$ capsh --print # capabilities do shell

$ getcap /usr/bin/ping

$ setcap cap_net_bind_service=+ep /usr/bin/node

$ setcap -r /usr/bin/node # remove caps

# seccomp

$ strace -c ls # conta syscalls

# Docker: --security-opt seccomp=policy.json

12

DevOps, Containers & Automação

Docker · Ansible · tmux · Git · performance tuning · chroot

Expert

Docker & Containers

$ docker run -d -p 8080:80 --name web nginx

$ docker exec -it web bash

$ docker logs -f web

$ docker ps -a

$ docker images

$ docker build -t myapp:v1 .

$ docker pull ubuntu:22.04

$ docker push user/myapp:v1

$ docker volume create mydata

$ docker network create mynet

$ docker inspect web

$ docker stats

$ docker compose up -d

$ docker compose down -v

# Limpeza

$ docker system prune -af

$ docker rmi $(docker images -q -f dangling=true)

tmux & Screen — Multiplexadores

Atalho	Ação
Ctrl+b c	Nova janela
Ctrl+b n / p	Próxima / anterior janela
Ctrl+b 0-9	Vai para janela N
Ctrl+b %	Split vertical
Ctrl+b "	Split horizontal
Ctrl+b setas	Navega painéis
Ctrl+b d	Detach (sessão continua)
Ctrl+b [	Modo scroll (q=sair)
Ctrl+b :resize-pane -R 5	Redimensiona painel

$ tmux new -s mysession

$ tmux attach -t mysession

$ tmux ls # lista sessões

$ tmux kill-session -t mysession

Git Essencial para Sysadmin

$ git init / git clone URL

$ git status / git diff

$ git add -A && git commit -m "msg"

$ git push origin main

$ git pull --rebase

$ git log --oneline --graph --all

$ git stash / git stash pop

$ git branch -a

$ git checkout -b feature/nova

$ git merge feature/nova

$ git rebase main

$ git reset --hard HEAD~1

$ git tag -a v1.0 -m "release"

chroot, recuperação & comandos power

# chroot — recuperação de sistema

$ mount /dev/sda1 /mnt

$ mount --bind /dev /mnt/dev

$ mount --bind /proc /mnt/proc

$ mount --bind /sys /mnt/sys

$ chroot /mnt /bin/bash

# Comandos de Rescue

$ grub-install /dev/sda # reinstala GRUB

$ update-grub

$ fsck -y /dev/sda1

# One-liners úteis

$ watch -n 1 df -h # monitora a cada 1s

$ yes n | cmd # responde 'n' automaticamente

$ time cmd # mede tempo de execução

$ timeout 10 cmd # limita execução a 10s

$ parallel -j4 gzip ::: *.log # paralelo

QR

Quick Reference — Exit Codes & Atalhos

Referência rápida para uso diário

Todos os Níveis

Exit Codes Comuns

Código	Significado
0	Sucesso
1	Erro geral
2	Uso incorreto (shell builtin)
126	Comando encontrado mas não executável
127	Comando não encontrado
128+N	Terminou com sinal N
130	SIGINT (Ctrl+C)
137	SIGKILL (128+9)
143	SIGTERM (128+15)

Atalhos de Terminal

Atalho	Ação
Ctrl+A	Início da linha
Ctrl+E	Fim da linha
Ctrl+U	Apaga até o início
Ctrl+K	Apaga até o fim
Ctrl+W	Apaga palavra anterior
Ctrl+R	Busca no histórico
Ctrl+L	Limpa terminal (= clear)
Ctrl+C	Interrompe processo
Ctrl+Z	Suspende processo
Ctrl+D	EOF / logout
Alt+.	Último argumento do comando anterior
!!	Repete último comando
!$	Último argumento do comando anterior
!cmd	Último comando iniciado com "cmd"

Pacotes: apt (Debian/Ubuntu) & dnf (RHEL/Fedora)

# apt (Debian/Ubuntu)

$ apt update && apt upgrade

$ apt install nginx

$ apt remove nginx

$ apt autoremove

$ apt search nginx

$ apt show nginx

$ dpkg -l # lista pacotes

$ dpkg -L nginx # arquivos do pacote

# dnf (RHEL/Fedora/CentOS)

$ dnf update

$ dnf install nginx

$ dnf remove nginx

$ rpm -qa # todos os pacotes

$ rpm -ql nginx # arquivos do pacote