1.1 Onde você encontra Linux (mesmo se seu laptop é Windows/Mac)

• Servidores de produção — a esmagadora maioria roda Linux.
• Contêineres — a imagem base (Alpine, Debian, Ubuntu) é Linux; depurar um container é depurar Linux.
• CI/CD — os runners do GitHub Actions / GitLab CI são Linux; quando o pipeline quebra, você lê logs de shell.
• Nuvem — VMs, funções, Kubernetes: Linux por baixo.
• Seu ambiente — macOS é Unix (o shell transfere quase todo); Windows tem o WSL (Windows Subsystem for Linux), praticamente obrigatório para dev hoje.

1.2 A filosofia Unix

1.3 Shell × terminal × bash

2.1 A árvore (FHS — Filesystem Hierarchy Standard)

2.2 Navegar e manipular

pwd                    # onde estou
cd /var/log ; cd - ; cd ~   # ir; voltar ao anterior; ir para home
ls -lah                # long, all (ocultos), human-readable
cp -r src/ dst/        # -r para diretórios; -i pergunta antes de sobrescrever
mv a b ; mkdir -p x/y/z ; rm -rf lixo/   # -p cria a cadeia; -rf recursivo forçado (CUIDADO)
ln -s /caminho/real link   # symlink (atalho); sem -s é hard link

2.3 Globbing (o shell expande, não o comando)

• * = qualquer sequência (menos / e, por padrão, arquivos ocultos); ? = um caractere; [abc] = um dos listados; {png,jpg} = brace expansion (não é glob, é lista literal).
• O shell expande o glob antes de passar ao comando — rm *.txt vira rm a.txt b.txt. Se nenhum arquivo casa, bash por padrão passa o *.txt literal (cuidado; shopt -s nullglob muda isso).
• ** (globstar, shopt -s globstar) = recursivo.

2.4 find — o canivete

find . -name "*.log" -type f -mtime +7 -size +10M        # logs .log, arquivos, >7 dias, >10MB
find /var/log -name "*.gz" -mtime +30 -delete            # apagar antigos
find . -type f -name "*.tmp" -exec rm {} +               # executar um comando por lote de resultados
find . -type d -empty                                     # diretórios vazios

-exec ... {} + agrupa os resultados numa chamada só (eficiente); {} \; chama uma vez por arquivo.

2.5 Permissões

-rwxr-xr--  1 ana  devs  4096  ago 30 14:00  deploy.sh
│└┬┘└┬┘└┬┘    │    │
│ │  │  └── outros (o): r--   (só leitura)
│ │  └───── grupo   (g): r-x   (ler e executar)
│ └──────── dono    (u): rwx   (ler, escrever, executar)
└────────── tipo: - arquivo | d diretório | l link

chmod 750 deploy.sh          # u=rwx(7) g=rx(5) o=nada(0)  → octal
chmod u+x,go-w deploy.sh     # simbólico: adiciona x ao dono, remove w de grupo/outros
chown ana:devs deploy.sh     # dono:grupo (precisa de root/sudo)
umask 022                    # máscara de criação: novos arquivos nascem 644, dirs 755

• Bits especiais: setuid (roda com o dono do arquivo — usado com cuidado, ex.: passwd), setgid (em diretório: arquivos herdam o grupo), sticky (/tmp: só o dono apaga seu arquivo).
• Não confunda "não consigo apagar este arquivo (só leitura)" — o que importa é o w no diretório, não no arquivo.
• sudo executa um comando como outro usuário (padrão: root). Configurado em /etc/sudoers. Princípio: use o mínimo necessário.

3.1 stdin, stdout, stderr e redirecionamento

comando > out.txt 2> err.txt        # separa saída e erros
comando > tudo.txt 2>&1             # junta os dois no mesmo arquivo (ordem importa!)
comando 2>&1 | grep erro            # manda stderr para o pipe também
comando < entrada.txt               # stdin de um arquivo
comando > /dev/null 2>&1            # descarta tudo

cat <<'EOF' > config.txt            # here-doc: bloco de texto literal (aspas em EOF = sem expansão)
porta=8080
host=localhost
EOF

grep foo <<< "$VARIAVEL"            # here-string: passa uma string como stdin

3.2 O toolkit de leitura

• cat (concatena/mostra), less (paginador — / busca, G vai ao fim, F = "follow" como tail -f), head -n 20, tail -n 50, tail -f app.log (segue em tempo real), tail -F (segue mesmo com rotação).
• wc -l (linhas), -w (palavras), -c (bytes).

3.3 grep — buscar

grep -i "error" app.log            # -i case-insensitive
grep -rn "TODO" src/               # -r recursivo, -n com número de linha
grep -v "healthcheck" access.log   # -v inverte (linhas que NÃO casam)
grep -E "warn|error|fatal" app.log # -E regex estendida (ou grep -e ... -e ...)
grep -c "200 " access.log          # -c conta as linhas que casam
grep -A2 -B1 "Exception" app.log   # contexto: 2 linhas depois, 1 antes
grep -o "user=[a-z]*" app.log      # -o só a parte que casou

3.4 sed — editar fluxo

sed 's/antigo/novo/' arq          # substitui a 1ª ocorrência por linha
sed 's/antigo/novo/g' arq         # g = global (todas na linha)
sed -i.bak 's|/old/path|/new/path|g' config   # -i edita o arquivo (com backup .bak); | como delimitador
sed -n '10,20p' arq               # -n silencia; imprime só as linhas 10 a 20
sed '/^#/d; /^$/d' config          # apaga comentários e linhas vazias

3.5 awk — colunas, filtros, agregação

awk '{print $1, $4}' access.log            # $1, $4 = campos (por espaço); $0 = linha inteira; NF = nº de campos
awk -F: '{print $1}' /etc/passwd           # -F: separador ':'
awk '$9 == 500 {print $7}' access.log      # só linhas onde o campo 9 é 500, imprime o 7
awk '$NF > 1.0 {c++} END {print c}' timings # conta linhas cujo último campo > 1.0
awk -F, '{s[$2]+=$3} END{for(k in s) print k, s[k]}' vendas.csv  # soma por chave
awk 'NR%100==0' huge.log                   # NR = nº da linha; amostra 1 a cada 100

3.6 O resto do arsenal

3.7 jq — JSON não é texto de linhas

curl -s api/users | jq '.[] | {id, nome: .name}'      # seleciona e reformata
jq -r '.items[].sku' data.json                        # -r = raw (sem aspas), um por linha
kubectl get pods -o json | jq '.items[] | select(.status.phase != "Running") | .metadata.name'
jq 'map(.valor) | add' vendas.json                    # soma

Regra: para texto tabular/linhas, use grep/sed/awk; para JSON, use jq (e yq para YAML). Não tente parsear JSON com regex.

4.1 Ver os processos

ps aux                       # todos os processos, formato BSD (USER PID %CPU %MEM ... COMMAND)
ps -ef                       # estilo System V (com PPID)
ps aux | grep '[n]ginx'      # o [n] evita que o grep encontre a si mesmo
pgrep -af node               # PIDs (e linha de comando) que casam
top      /    htop           # interativo; htop é bem melhor (barras, filtro, kill visual)
pstree -p                    # árvore de processos

4.2 Sinais

kill 1234            # SIGTERM ao PID 1234
kill -9 1234         # SIGKILL (só se o TERM não funcionou)
kill -HUP $(pgrep nginx)   # recarregar nginx
pkill -f "python worker.py"   # por padrão de linha de comando
killall node        # por nome exato do executável

4.3 Job control

./demorado.sh &          # roda em background; imprime o PID
jobs                     # lista os jobs desta sessão
fg %1                    # traz o job 1 para foreground
Ctrl+Z                   # suspende o job em foreground
bg %1                    # retoma o job 1 em background

nohup ./servidor.sh > log.txt 2>&1 &   # imune a SIGHUP; sobrevive ao fechar o terminal
disown -h %1             # tira o job da tabela de jobs (também sobrevive ao logout)

Para tarefas que precisam mesmo sobreviver e você poder voltar a elas: tmux (Módulo 8) > nohup.

4.4 Exit codes e encadeamento

• Todo comando retorna um exit code: 0 = sucesso, qualquer outro (1–255) = erro. Consulte com echo $?.
• cmd1 && cmd2 — roda cmd2 só se cmd1 teve sucesso.
• cmd1 || cmd2 — roda cmd2 só se cmd1 falhou (fallback).
• cmd1 ; cmd2 — roda os dois independentemente.
• timeout 30 ./lento.sh — mata o comando se passar de 30s (exit 124).
• watch -n 5 'df -h /' — re-executa a cada 5s.
• Num pipe, o exit code é o do último comando (por isso set -o pipefail — Módulo 6).

5.1 Quoting — o tópico mais importante do shell

# o bug clássico:
arquivo="meu relatório.pdf"
rm $arquivo        # vira: rm meu relatório.pdf  → tenta apagar "meu" e "relatório.pdf"
rm "$arquivo"      # CERTO: rm "meu relatório.pdf"

for f in *.txt; do            # glob no for: OK sem aspas (é a exceção)
  mv "$f" "processados/$f"    # mas SEMPRE aspas ao USAR a variável
done

5.2 Variáveis e substituição de comando

nome="Ana"            # SEM espaços em volta do = (nome = "Ana" seria um comando "nome")
echo "Olá, ${nome}!"   # ${} delimita: útil em "${nome}_backup"

hoje=$(date +%F)      # command substitution: captura a saída (moderno; use isto)
count=`ls | wc -l`    # backticks: forma antiga, não aninha bem — evite
export API_URL="https://..."   # export: torna disponível para processos-filho

5.3 Expansão de parâmetros (parameter expansion)

${VAR:-padrao}     # usa "padrao" se VAR não está setada ou vazia
${VAR:=padrao}     # idem, e ATRIBUI a VAR
${VAR:?erro msg}   # aborta com a mensagem se VAR está vazia (ótimo para validar args)
${#VAR}            # comprimento
${VAR#prefixo}     # remove o menor prefixo que casa; ## = o maior
${VAR%.txt}        # remove sufixo (% menor, %% maior) — ${arquivo%.*} tira a extensão
${VAR/antigo/novo} # substitui a 1ª; // substitui todas
${VAR:0:3}         # substring (posição 0, tamanho 3)
${ARQ##*/}         # basename "manual"; ${ARQ%/*} = dirname

5.4 Outras expansões

echo {1..5}              # 1 2 3 4 5   (brace expansion)
echo arq_{a,b,c}.txt     # arq_a.txt arq_b.txt arq_c.txt
mkdir -p projeto/{src,test,docs}
echo $(( 3 * (2 + 4) ))  # aritmética: 18
i=0; (( i++ )); echo $i  # 1
echo ~ $HOME             # tilde expansion → /home/ana

5.5 Arrays e condicionais

servidores=(web1 web2 web3)
echo "${servidores[1]}"          # web2 (índice 0-based)
echo "${#servidores[@]}"        # 3 (tamanho)
for s in "${servidores[@]}"; do echo "deploy em $s"; done

# condicionais: use [[ ]] no bash (mais seguro que [ ])
if [[ -f "$arquivo" && -r "$arquivo" ]]; then echo "existe e é legível"; fi
if [[ "$env" == prod ]]; then ...; elif [[ "$env" == staging ]]; then ...; fi
if [[ "$n" -gt 10 ]]; then ...; fi       # -eq -ne -lt -le -gt -ge para números
[[ "$s" =~ ^[0-9]+$ ]] && echo "é número"      # =~ regex

6.1 O cabeçalho que todo script deve ter

#!/usr/bin/env bash
set -euo pipefail
IFS=$'\n\t'

# set -e        : aborta o script se um comando falhar (exit != 0)
# set -u        : erro se usar variável não definida (pega typos)
# set -o pipefail: o pipe falha se QUALQUER comando dele falhar (não só o último)
# IFS restrito  : word splitting só em newline e tab, não em espaço → menos surpresa

6.2 trap — limpeza garantida

tmpdir=$(mktemp -d)
cleanup() {
  rm -rf "$tmpdir"
  echo "limpeza feita"
}
trap cleanup EXIT      # roda cleanup ao sair do script, por qualquer motivo (sucesso, erro, Ctrl+C)
trap 'echo "interrompido na linha $LINENO"' ERR

trap ... EXIT é o "defer/finally" do shell — use para remover temporários, liberar locks, restaurar estado.

6.3 Funções e argumentos

log()  { echo "[$(date +%T)] $*" >&2; }        # log vai para stderr, não polui a saída
die()  { log "ERRO: $*"; exit 1; }

processar() {
  local entrada=$1              # local: não vaza para o escopo global
  local destino=${2:-/tmp/out}  # default
  [[ -f "$entrada" ]] || die "não achei $entrada"
  # ...
}

# dentro de uma função ou do script:
# $1 $2 ...  args posicionais   |   $#  quantidade   |   "$@"  todos (preservando)   |   $0  nome do script
processar "$@"              # SEMPRE "$@" com aspas (não $* nem $@ sem aspas)

6.4 Parsing de opções com getopts

verbose=0; output=""
while getopts "vo:h" opt; do
  case $opt in
    v) verbose=1 ;;
    o) output=$OPTARG ;;
    h) echo "uso: $0 [-v] [-o arquivo] entrada..."; exit 0 ;;
    *) exit 2 ;;
  esac
done
shift $((OPTIND - 1))     # agora "$@" são os argumentos posicionais restantes

6.5 ShellCheck — não negociável

shellcheck script.sh (ou o plugin da IDE) analisa estaticamente e pega: expansão sem aspas, uso de variável não declarada, [ ] vs [[ ]], cd sem checar, glob em contexto errado, comparação de string com -eq, e dezenas de outros. Rode no CI com falha em warnings. Um script que passa no ShellCheck já evitou a maioria dos bugs clássicos.

6.6 Idempotência e quando parar

• Idempotente: rodar duas vezes tem o mesmo efeito. mkdir -p (não falha se existe), ln -sfn, checar antes de criar, rsync em vez de cp cego. Scripts de setup/deploy devem ser idempotentes.
• mktemp para arquivos temporários (nome único, sem race, sem colisão) — nunca /tmp/meuarquivo.
• Locking (flock) se o script não pode rodar duas vezes ao mesmo tempo (cron).

7.1 Variável de shell × variável de ambiente

• Uma variável de shell (x=1) existe só no shell atual. export x a promove a variável de ambiente, herdada por todo processo-filho.
• env lista as de ambiente; set lista todas (shell + ambiente + funções).
• x=1 comando — define x só para aquela invocação.
• Variáveis clássicas: PATH, HOME, USER, SHELL, PWD, LANG/LC_*, TERM, EDITOR, TZ.

7.2 PATH

echo $PATH
# /home/ana/.local/bin:/usr/local/bin:/usr/bin:/bin

which python3        # mostra qual executável seria usado
type -a python3      # todos os candidatos (e se é alias/função/builtin)
command -v node      # forma portável de "existe?"

• Quando você digita foo, o shell procura foo em cada diretório do PATH, na ordem, e usa o primeiro. Por isso um ./node_modules/.bin ou ~/.local/bin no início "sombreia" o do sistema.
• Adicionar ao PATH (no arquivo de config): export PATH="$HOME/.local/bin:$PATH".
• Nunca coloque . (diretório atual) no PATH — risco de segurança (rodar um binário malicioso ao cd num diretório).

7.3 Quais arquivos de config são lidos (bash)

7.4 Aliases, funções e histórico

alias ll='ls -lah'
alias gs='git status'
gclone() { git clone "git@github.com:$1.git" && cd "$(basename "$1")"; }   # função aceita argumento; alias não

# histórico
history                # lista
!!                     # último comando; sudo !! = re-roda com sudo
!$                     # último argumento do comando anterior
Ctrl+R                 # busca reversa incremental no histórico (o atalho mais útil do shell)
export HISTCONTROL=ignoredups:erasedups
export HISTSIZE=100000

7.5 Dotfiles versionados

• Seus arquivos de config (.bashrc, .gitconfig, .tmux.conf, .vimrc, .ssh/config...) num repositório git — reprodutível numa máquina nova em minutos.
• Ferramentas: um repo "bare" com alias, GNU Stow (symlinks), chezmoi (templates, segredos, multi-máquina), yadm.
• Nunca commite segredos (chaves privadas, tokens) — use .gitignore, ou o suporte a segredos do chezmoi, ou um cofre.

8.1 SSH

ssh-keygen -t ed25519 -C "ana@laptop"        # gera par de chaves (ed25519 > rsa)
ssh-copy-id ana@servidor                     # instala a pública no ~/.ssh/authorized_keys do servidor
ssh ana@servidor                             # login sem senha

# ~/.ssh/config — o arquivo que muda sua vida
Host prod
  HostName 203.0.113.10
  User deploy
  IdentityFile ~/.ssh/id_ed25519
  ForwardAgent yes
Host db-interno
  HostName 10.0.1.5
  ProxyJump prod            # pula pelo bastion "prod" automaticamente
# agora: ssh prod   |   ssh db-interno

• ssh-agent guarda a chave descriptografada na memória: eval "$(ssh-agent)"; ssh-add (uma vez por sessão).
• Port forwarding: ssh -L 5432:localhost:5432 prod — acessa o Postgres do servidor como se fosse localhost:5432 na sua máquina (túnel local). -R faz o inverso (remoto → local); -D cria um proxy SOCKS.
• Rodar um comando e sair: ssh prod 'df -h /'.
• Hardening do servidor (Módulo 9): desabilitar login por senha e login de root, mudar/filtrar a porta, fail2ban.

8.2 Transferir arquivos: scp e rsync

scp arquivo.tar.gz prod:/tmp/           # cópia simples (bom para 1 arquivo)
scp -r pasta/ prod:/var/www/           # recursivo

rsync -avz --progress ./dist/ prod:/var/www/app/
# -a arquivo (recursivo + permissões + tempos + links)   -v verboso
# -z comprime na transferência   --progress mostra andamento
rsync -avz --delete --exclude='.git' ./ prod:/srv/app/
# --delete: remove no destino o que não existe na origem (espelho — CUIDADO)
# --dry-run: mostra o que faria sem fazer (use SEMPRE antes de --delete)

8.3 Compressão

tar czf arquivo.tar.gz pasta/     # c criar, z gzip, f arquivo
tar xzf arquivo.tar.gz            # x extrair   |   tar tzf = listar sem extrair
tar xzf arquivo.tar.gz -C /destino
tar caf arquivo.tar.zst pasta/    # a = detecta pela extensão; zstd é rápido e comprime bem
zip -r a.zip pasta/  ;  unzip a.zip

8.4 tmux — sessões que sobrevivem

tmux new -s deploy       # nova sessão nomeada
# ... rode um processo longo ...
Ctrl-b d                 # "detach" — sai deixando tudo rodando
# feche o SSH, o laptop, volte amanhã:
tmux attach -t deploy    # reconecta, tudo como estava
tmux ls                  # lista sessões

Prefixo padrão Ctrl-b: c nova janela, %/" divide painel, o alterna painel, [ modo scroll. É o jeito certo de rodar deploys, migrações e testes longos em servidores — não nohup.

8.5 systemd — serviços no Linux moderno

systemctl status nginx           # estado, PID, últimas linhas de log
systemctl start|stop|restart|reload nginx
systemctl enable --now nginx     # inicia agora E no boot
systemctl list-units --failed    # o que está quebrado

journalctl -u nginx -f           # logs desse serviço, seguindo (como tail -f)
journalctl -u nginx --since "1 hour ago" -p err
journalctl -b                    # logs deste boot

# /etc/systemd/system/minhaapp.service — rodar SUA app como serviço
[Unit]
Description=Minha App
After=network.target

[Service]
ExecStart=/usr/local/bin/minhaapp
Restart=on-failure
User=app
Environment=NODE_ENV=production
WorkingDirectory=/srv/app

[Install]
WantedBy=multi-user.target
# systemctl daemon-reload ; systemctl enable --now minhaapp

systemd timers (.timer + .service) são a alternativa moderna ao cron — com logs no journal, dependências, e OnCalendar= legível. cron (crontab -e) ainda é onipresente e simples para tarefas periódicas.

8.6 O "modern CLI"

9.1 Rede

ip a                        # interfaces e IPs (substitui o antigo ifconfig)
ip r                        # tabela de rotas (qual gateway)
ss -tlnp                    # portas TCP em LISTEN, com o processo (substitui netstat)
ss -tnp | grep :5432        # quem está conectado ao Postgres
dig +short exemplo.com      # resolução DNS (ou nslookup / host)
getent hosts exemplo.com    # resolução como a app veria (respeita /etc/hosts, nsswitch)
curl -sv https://api/health # -v mostra handshake TLS, headers, redirects
curl -o /dev/null -s -w '%{http_code} %{time_total}s\n' https://api/
nc -zv host 6379            # a porta está aberta? (teste de conectividade cru)
ping -c 3 host ; traceroute host   # alcance e caminho
mtr host                    # ping + traceroute contínuo (ótimo para perda de pacote)

• Ordem de diagnóstico de "não conecto ao serviço X": resolve o DNS? (dig) → há rota? (ping/ip r) → a porta responde? (nc -zv) → o TLS negocia? (curl -v) → a app responde certo? (corpo/HTTP status). Vá camada por camada.
• /etc/hosts sobrepõe o DNS — útil para testar, fonte de bug quando esquecido.
• tcpdump -i any port 5432 -c 20 (com sudo) para ver os pacotes quando nada mais explica.

9.2 Disco e I/O

df -h                       # uso por ponto de montagem — "disco cheio?"
df -i                       # uso de INODES — pode encher antes do espaço (muitos arquivos pequenos)
du -sh * | sort -h          # o que ocupa espaço no diretório atual
du -sh /var/* 2>/dev/null | sort -h
ncdu /var                   # navegável — o jeito rápido de achar o vilão
lsblk                       # dispositivos de bloco e montagens
lsof +D /var/log            # quem tem arquivos abertos ali (útil: "apaguei o log mas o disco não liberou")

9.3 Saúde da máquina

O método USE (Brendan Gregg, ver apostila de Observabilidade & SRE): para cada recurso (CPU, memória, disco, rede), cheque Utilization, Saturation, Errors. "Servidor lento" quase sempre é um dos quatro saturado — descubra qual antes de agir.

9.4 Pacotes

• Debian/Ubuntu: apt update, apt install, apt list --installed, dpkg -l, apt-cache policy pkg.
• RHEL/Fedora: dnf install, rpm -qa. Arch: pacman -S. Alpine: apk add.
• Universais: brew (macOS/Linux), snap/flatpak, mise/asdf (runtimes de linguagem por projeto).
• Por que contêineres: em vez de instalar dependências na máquina (e brigar com versões e drift), a imagem carrega o ambiente exato. Um dev moderno instala pouca coisa na máquina base.

9.5 Segurança mínima de um servidor

• SSH: só chave (PasswordAuthentication no), sem login de root (PermitRootLogin no), fail2ban contra brute force, e — melhor ainda — SSH só via bastion ou VPN, não exposto à internet.
• Menor privilégio: a app roda como um usuário dedicado sem shell (useradd -r -s /usr/sbin/nologin app), com acesso só ao que precisa. sudo granular, não "sudo para tudo".
• Firewall: ufw / firewalld / security groups da nuvem — só as portas necessárias.
• Atualizações de segurança automáticas (unattended-upgrades).
• Segredos: variáveis de ambiente são melhores que hardcode, mas aparecem em /proc/<pid>/environ, em ps auxe, e podem vazar em logs/crash dumps. Para segredos sérios: um cofre (Vault), arquivos com permissão 600 lidos em runtime, ou os secrets do orquestrador. Nunca commite; nunca passe na linha de comando (fica no history e no ps).
• No shell: um espaço antes do comando ( export TOKEN=...) o mantém fora do history se HISTCONTROL=ignorespace; ainda assim, prefira não digitar segredos.

10.1 Onde isso aparece no trabalho

• Backend: depurar o container, ler logs em produção, escrever o entrypoint/healthcheck, o Dockerfile, os scripts de seed/migração.
• DevOps / Platform / SRE: o dia inteiro — scripts de automação, systemd, troubleshooting, o "cola" entre ferramentas.
• Dados: pipelines, cron, mover arquivos, inspecionar dumps, jq/awk antes de subir para o warehouse.
• Qualquer dev: o CI falhou — a mensagem é de shell; o build é um script; o "funciona na minha máquina" costuma ser diferença de shell/ambiente.

Não é uma vaga de "shell scripter" — é uma competência transversal que separa quem se vira sozinho de quem depende de outra pessoa para cada tarefa de infra.

10.2 Roadmap de estudo (5–7 semanas)

10.3 Banco de perguntas de entrevista (com a resposta que aprova)

10.4 O que mostrar (portfólio)

1. Dotfiles no GitHub: .bashrc/.zshrc organizados, .ssh/config (sem chaves!), aliases e funções úteis, com um install.sh idempotente. Sinaliza que você vive no terminal.
2. Um script de automação real (deploy, backup, setup de ambiente): com header robusto, getopts, trap, logging, idempotente, README, e um badge de ShellCheck passando no CI.
3. Um "one-liner cookbook": uma coleção comentada de pipelines úteis (análise de log, manipulação de JSON, operações em massa de arquivos) — mostra fluência com o toolkit.
4. Um .service + timer do systemd para uma app sua, documentado.
5. Um writeup de troubleshooting: "diagnostiquei X" com os comandos e o raciocínio (rede, disco ou performance).

10.5 Fontes para continuar

• Referência: The Linux Command Line (William Shotts, gratuito online); Wicked Cool Shell Scripts; o Bash Guide do "Greg's Wiki" (BashFAQ, BashPitfalls — leitura essencial sobre os erros comuns); man bash e help para builtins.
• Ferramentas: a documentação do ShellCheck (cada código de erro tem explicação); tldr (exemplos curtos por comando); explainshell.com (cola um comando, explica cada parte).
• Performance: os materiais de Brendan Gregg (o método USE, "Linux Performance").
• Prática: "Bandit" (OverTheWire) para praticar shell num jogo; "Command Line Challenge"; resolver tarefas reais só no terminal por um tempo.