Sistemas Operacionais: Linux para servidores¶

Quase toda a infraestrutura da internet, da nuvem e dos contêineres roda sobre Linux; para quem trabalha com backend, DevOps ou SRE ele é pré-requisito. Esta página cobre a administração de servidores Linux (Debian/Ubuntu): da linha de comando à configuração de discos, rede e serviços.

Sobre os comandos

O livro-fonte foi escrito para o Debian 9/Ubuntu 22.04 e usa algumas ferramentas antigas (ifconfig, route, netstat, service, squid3). Aqui aparecem os comandos atuais ao lado, e os trechos marcados como complemento não estão no livro. Convenção do texto: # no início do comando = executar como root; $ = qualquer usuário.

Conceitos de sistemas operacionais¶

Definição: sistema operacional (SO)

Sistema operacional é o software que gerencia o hardware (processador, memória, armazenamento, entrada e saída) e oferece serviços padronizados aos programas e aos usuários. Sem ele, a máquina é um gabinete inerte; com ele, vários programas compartilham o mesmo hardware de forma organizada e segura.

flowchart TB
    U[Usuários] --> A[Aplicativos: navegador, editor, banco de dados]
    A --> SO[Sistema operacional: kernel, drivers, serviços]
    SO --> H[Hardware: CPU, memória, disco, rede, dispositivos]

Hardware que o SO gerencia¶

Processador (CPU): executa instruções em linguagem de máquina. Tem unidade de execução, decodificação de instruções, registradores e caches (cópias de dados da memória principal, para acesso rápido). Pode ter vários núcleos.
Memória principal (RAM): dividida em células (em geral de 8 bits), cada uma com um endereço único; é volátil. Dados e programas precisam estar na RAM para serem executados.
Armazenamento: discos rígidos, SSDs e outros dispositivos não voláteis; têm um controlador que executa as leituras e gravações.
Dispositivos de entrada e saída (E/S): teclado, mouse, vídeo, rede; cada um tem um controlador e um driver (software do SO que sabe conversar com ele). Os controladores avisam o processador por interrupções.

Tipos de sistema operacional¶

Critério	Tipos
Quantas tarefas	Monotarefa (uma aplicação por vez, como o antigo MS-DOS); multitarefa (vários programas "ao mesmo tempo", dividindo o tempo do processador); multiprocessador (usa vários processadores/núcleos de verdade)
Quantos usuários	Monousuário ou multiusuário (vários usuários, cada um com seus arquivos e permissões)
Uso	Desktop (Windows, macOS, distribuições Linux) e servidor (Linux, Windows Server, Unix); móveis (Android, iOS); embarcados e de tempo real

Servidores têm necessidades diferentes de desktops: ficam ligados o tempo todo, são acessados pela rede e precisam de desempenho, estabilidade e segurança. Funções comuns: arquivos (compartilhamento), banco de dados, web, proxy (gateway com cache e registro de acessos), DHCP (distribui IPs), DNS, e-mail e backup.

Kernel, modos de acesso, processos e threads¶

Kernel (núcleo): a parte principal do SO, com as instruções de gerenciamento do hardware e das tarefas. Quase todas as outras partes (interface gráfica, utilitários) dependem dele.
Modos de acesso: no modo usuário os programas só executam instruções não privilegiadas; no modo kernel (supervisor) o SO executa instruções privilegiadas (acessar hardware, gerenciar memória). Quando um programa precisa de um serviço do SO, faz uma chamada de sistema (system call) que troca de modo, o que protege o sistema de programas defeituosos.
Processo é um programa em execução, com seu espaço de memória, estado e recursos (arquivos abertos). Thread é uma linha de execução dentro de um processo: threads do mesmo processo compartilham a memória, o que torna a comunicação rápida (e a concorrência, perigosa: Java avançado).
Escalonamento (complemento): com mais processos do que núcleos, o SO alterna entre eles em fatias de tempo (time slicing) com troca de contexto (salvar e restaurar o estado). Estados típicos: pronto, executando, bloqueado (esperando E/S). Algoritmos comuns: round-robin, por prioridade, multilevel feedback queue.
Condições de corrida e deadlock (complemento):* dois processos disputando o mesmo recurso podem produzir resultados errados (race condition), e dois processos esperando um pelo outro formam um deadlock; resolvem-se com *sincronização (mutex, semáforos) e ordem consistente de aquisição de recursos.
Ferramentas: Gerenciador de Tarefas (Windows), Monitor do Sistema, ps, top/htop (Linux). Serviços/daemons são processos de segundo plano iniciados com o sistema (services.msc, systemctl).

Memória: virtual, paginação e swap¶

O SO dá a cada processo um espaço de endereços próprio (memória virtual), isolado dos outros, e o traduz para a memória física por tabelas de páginas (paging): a memória é dividida em páginas de tamanho fixo (por exemplo, 4 KB).
Quando falta RAM, páginas pouco usadas são copiadas para o disco (arquivo de paginação no Windows; partição/arquivo swap no Linux), "desafogando" a memória, porém muito mais lento. Excesso de paginação causa thrashing (a máquina passa o tempo trocando páginas). Sinal de alerta: uso de swap crescente.
Falha de página (page fault): o programa acessa uma página que não está na RAM; o SO a carrega do disco. Cache de disco usa RAM livre para acelerar leituras.

Sistemas de arquivos¶

O sistema de arquivos organiza como os dados são gravados no disco (nomes, diretórios, permissões, onde cada bloco está):

Sistema	Onde	Observação
FAT / FAT32	Windows antigo, pen drives	Simples e compatível; arquivo máximo de 4 GB, sem permissões
NTFS	Windows	Permissões, criptografia, *journaling*, compressão
ext3 / ext4	Linux	Evolução do ext2 com journaling (registro das mudanças para recuperar após falha); ext4 é o padrão atual
XFS, Btrfs, ZFS	Linux/Unix	Volumes grandes, snapshots, integridade
APFS	macOS/iOS	Snapshots e criptografia

Montagem (Linux): em Unix, tudo parte de uma única árvore (/) e dispositivos são montados em diretórios (mount /dev/sdb1 /mnt/dados; crie o diretório de destino antes). Estruturas de diretórios do Windows (C:\Windows, C:\Users) e do Linux (/etc, /home, /var) em FHS.

Do código-fonte ao programa em execução¶

Tradutor	O que faz	Exemplos
Montador (assembler)	Traduz a linguagem de montagem (Assembly) para código de máquina	NASM
Compilador	Traduz todo o código de alto nível para código objeto/executável antes de rodar	C, C++, Go, Rust
Interpretador	Executa as instruções diretamente, sem gerar um programa	Python, PHP, JavaScript (com JIT)
Ligador (linker)	Junta o código objeto às bibliotecas necessárias e produz o executável	`ld`, link do C

Em plataformas como a JVM, o código é compilado para um bytecode e depois interpretado/compilado por um JIT (Java). Uma IDE reúne editor, compilador/depurador e outras ferramentas.

Virtualização¶

Virtualização permite rodar várias máquinas virtuais (VMs), cada uma com seu SO, sobre um único computador físico. Um hipervisor divide CPU, memória e disco entre as VMs.

Tipo 1 (bare metal): o hipervisor roda direto sobre o hardware (VMware ESXi, Hyper-V, KVM, Xen): melhor desempenho; base da nuvem.
Tipo 2 (hospedado): roda como programa de um SO (VirtualBox, VMware Workstation): ideal para laboratório.
Recursos: snapshots, clonagem, backup e replicação de VMs, redes virtuais (NAT, bridge, rede interna). Contêineres (Docker) são uma alternativa mais leve, que compartilha o kernel do hospedeiro (Contêineres, Nuvem).

Instalação e administração (visão geral)¶

Instalação: Live CD/USB (testar sem instalar), particionamento, formatação, instalação de drivers, antivírus e atualizações automáticas; faça backup antes de formatar. Dual boot convive com outro SO; máquina virtual é mais seguro para testar.
Administração: usuários e grupos (permissões), serviços, instalação de programas (gerenciadores de pacotes no Linux), compactadores e backup, arquivos de lote (batch no Windows) e scripts de shell (Linux) para automatizar tarefas (Shell script), acesso remoto (RDP, VNC, SSH).
Comparação rápida: Windows (comercial, ~maioria dos desktops, forte em software corporativo e jogos); Linux (livre, núcleo + distribuições como Ubuntu, Debian, Red Hat; dominante em servidores e nuvem; software livre permite estudar, modificar e redistribuir); macOS (Apple, base Unix).

O que é Linux¶

Kernel (núcleo): o componente central do sistema operacional, a ponte entre os aplicativos e o hardware. Linux é o nome do kernel, criado por Linus Torvalds em 1991.
GNU: projeto de Richard Stallman (1984) que criou as ferramentas de um sistema livre (compiladores, editores, shell), mas ainda sem kernel. Juntos formam o GNU/Linux.
Distribuição (distro): o kernel empacotado com programas, instalador e gerenciador de pacotes — Debian, Ubuntu, CentOS/Rocky, Red Hat, Fedora, SUSE; até o Android é uma distribuição baseada no kernel Linux. Para servidores e nuvem, o Ubuntu Server LTS e o Debian são escolhas comuns.
Código aberto: pode ser estudado, modificado e redistribuído.

Definição: Kernel monolítico x microkernel

Microkernel: só o mínimo roda no kernel space; o resto (drivers, rede) são "servidores" no espaço do usuário. Kernel monolítico (o do Linux): rede, vídeo, sistemas de arquivos e outros recursos rodam no kernel space, o que é mais rápido; para não ficar rígido, o Linux usa módulos carregáveis (veja adiante).

Para estudar com segurança, use máquinas virtuais (VirtualBox) — dá para criar discos, quebrar configurações e desfazer sem risco.

Primeiros passos no shell¶

O shell é o interpretador de comandos: a interface entre o usuário e o kernel. O padrão é o bash (existem também sh, zsh, ksh...). Um servidor normalmente não tem interface gráfica, então toda a administração acontece pelo terminal.

Conceito	Detalhe
Prompt	`#` indica root; `$` indica usuário comum
root	Administrador com poder total (inclusive para apagar o sistema): use com cuidado
`su` / `su -`	Troca de usuário; `su - usuario` carrega o ambiente dele
`sudo`	Executa um comando com privilégios de root, conforme `/etc/sudoers` (editar com `visudo`)
`whoami` / `who am i`	Usuário efetivo atual / usuário que fez o login original
`history`, `!n`, `fc -l`	Histórico de comandos; `!12` repete o comando 12
`exit`, `logout`, `Ctrl+D`	Sair da sessão
`shutdown -h now`, `shutdown -r 10`, `shutdown -c`, `reboot`, `poweroff`	Desligar, reiniciar (em 10 min) e cancelar; evite o botão de energia (risco de corromper o disco)
Terminais virtuais	`Alt+F1…F6` (ou `Ctrl+Alt+F1…F6` a partir da interface gráfica)

Atalhos úteis do bash: Ctrl+A (início da linha), Ctrl+E (fim), Ctrl+U (recorta à esquerda), Ctrl+Y (cola), Ctrl+L (limpa a tela), Ctrl+C (interrompe o comando), Ctrl+D (fim de entrada/sai), Tab (completa nomes).

Como obter ajuda¶

Comando	Para quê
`man comando`	Manual completo do comando (as man pages têm seções: 1 comandos, 2 chamadas de sistema, 3 bibliotecas, 4 dispositivos, 5 arquivos de configuração, 7 miscelânea, 8 administração)
`comando --help`, `help cd`	Ajuda rápida (`help` serve para comandos internos do shell)
`apropos palavra`	Procura man pages por palavra-chave
`whatis comando`	Descrição de uma linha
`info comando`	Documentação navegável (`n`, `p`, `u`, `q`)
`whereis comando` / `which comando`	Onde estão o binário, a configuração e o manual / só o binário
`/usr/share/doc`	How-tos e documentação dos pacotes

Navegação e manipulação de arquivos¶

pwd                     # diretório atual
cd /var/log             # entra em um diretório
cd ~                    # home do usuário (/home/usuario; /root para o root)
cd ..                   # sobe um nível; cd - volta ao diretório anterior
ls -l                   # listagem detalhada
ls -a                   # inclui ocultos (nomes começados por ponto)
ls -R /etc              # recursiva
touch arquivo           # cria arquivo vazio (ou atualiza a data)
mkdir -p videos/terror  # cria a estrutura inteira
cp -r origem destino    # copia (-r para diretórios; -p preserva dono, permissões e datas)
mv origem destino       # move ou renomeia
rm -i arquivo           # remove pedindo confirmação
rm -r diretorio         # remove diretório e conteúdo (sem volta! cuidado como root)
rmdir diretorio         # só remove diretório vazio

A saída de ls -l, por exemplo drwxr-xr-x 2 root root 4096 abr 25 06:15 bin, tem os campos: tipo + permissões (d diretório, - arquivo, l link, c/b dispositivo de caractere/bloco, s socket, p named pipe), nº de links, dono, grupo, tamanho, data e nome.

Curingas (wildcards): * (qualquer sequência), ? (um caractere), [abc]/[!2] (um caractere do conjunto / exceto), {a,b,c} (expansão): touch arq{1,2,3}, ls *.png, ls arq[!2].txt.

O Linux diferencia maiúsculas de minúsculas (case sensitive): Arquivo, ARQUIVO e arquivo são três arquivos.

Complemento: permissões, pipes e processos¶

Itens que o livro menciona mas que são cobrados em qualquer entrevista de Linux:

chmod 750 script.sh        # permissões em octal: dono rwx (7), grupo r-x (5), outros --- (0)
chmod +x script.sh         # dá permissão de execução
chown usuario:grupo arq    # troca dono e grupo
grep -n "erro" app.log     # procura texto; -n mostra o número da linha
cat app.log | grep erro | wc -l    # pipe (|): saída de um comando vira entrada do próximo
comando > saida.txt 2>&1   # redireciona saída e erros
ps aux | grep nginx        # processos; top/htop para acompanhar em tempo real
kill -15 1234              # pede para o processo terminar (kill -9 força)
systemctl status|start|stop|enable nginx   # gerencia serviços (systemd)
journalctl -u nginx -f     # logs de um serviço
tail -f /var/log/syslog    # acompanha um log em tempo real

Permissões: r = 4 (ler), w = 2 (escrever), x = 1 (executar), somadas por dono / grupo / outros. Em diretórios, x permite entrar.

FHS: hierarquia de diretórios¶

O FHS (Filesystem Hierarchy Standard) padroniza a árvore de diretórios, garantindo que um software funcione em qualquer distribuição. Tudo começa na raiz /.

Diretório	Conteúdo
`/bin`, `/sbin`	Comandos essenciais para todos os usuários / para administração e recuperação (root)
`/boot`	Kernel e gerenciador de boot (GRUB)
`/dev`	Arquivos de dispositivos (`/dev/sda`, `/dev/sdb1`)
`/etc`	Arquivos de configuração do sistema e dos serviços
`/home`, `/root`	Diretórios pessoais dos usuários / do administrador
`/lib`	Bibliotecas compartilhadas e módulos do kernel (`/lib/modules/<versão>`)
`/media`, `/mnt`	Pontos de montagem de mídias removíveis / montagens temporárias
`/opt`	Programas fora da distribuição (geralmente proprietários)
`/srv`	Dados de serviços (ex.: `/srv/ftp`)
`/tmp`	Arquivos temporários
`/usr`	Programas e bibliotecas não essenciais ao boot
`/var`	Dados variáveis: logs (`/var/log`), filas, caches
`/proc`, `/sys`	Diretórios virtuais (em memória) mantidos pelo kernel, com informações de processos, hardware e estado do sistema

Editor Vim¶

Grande parte da configuração de um servidor é a edição de arquivos de texto, e o Vim (VI improved) está em praticamente todo servidor (e é cobrado em provas como a LPIC-1).

Modos: normal/comando (Esc: navegar, apagar, copiar), inserção (i, a, o: digitar) e visual (v: selecionar). Comandos de linha começam com :.
Sair: :w salva, :q sai, :wq salva e sai, :q! sai sem salvar, :e! recarrega o arquivo descartando alterações.
Mover: h j k l (esquerda, baixo, cima, direita), gg (início), G (fim), 0/$ (início/fim da linha), w/b (próxima/anterior palavra), 42G (linha 42).
Editar: x (apaga caractere), dd (apaga linha), dw (apaga palavra), yy (copia linha), p (cola), u (desfaz).
Buscar e substituir: /termo (busca, n/N para a próxima/anterior); :%s/antiga/nova/g (em todo o arquivo; com c pede confirmação).
Abrir já na linha: grep -n "termo" arquivo e depois vim +27 arquivo. Divisão de tela: :split, :vsplit, Ctrl+w w alterna.
Defina o editor padrão com update-alternatives --config editor.

Shell script¶

Um shell script é um arquivo de comandos que automatiza tarefas repetitivas (backup, configuração de rede, relatórios).

#!/bin/bash                      # "shebang": diz qual interpretador executa o arquivo
# Comentários começam com #

site="www.exemplo.com.br"        # variável: sem espaços ao redor do =; lê-se com $
agora=$(date)                    # captura a saída de um comando (a crase `date` é a forma antiga)
echo "Acesso o site $site em $agora"

read -p "Digite um número: " numero      # lê a entrada do usuário
if [ "$numero" -gt 20 ]; then            # espaços dentro dos colchetes são obrigatórios
    echo "Maior que 20"
elif [ "$numero" -ge 0 ]; then
    echo "Entre 0 e 20"
else
    echo "Negativo"
fi

case "$numero" in
    1) echo "um" ;;
    2) echo "dois" ;;
    *) echo "outro" ;;
esac

for i in $(seq 1 5); do echo "$i"; done

while [ "$dado" != "-1" ]; do read -r dado; done

main() {                         # funções organizam o script; chame a principal no final
    echo "olá"
}
main

chmod +x script.sh               # permissão de execução
./script.sh                      # ou: bash script.sh

Teste (`[ ... ]`)	Significado
`a = b`, `a != b`	Strings iguais / diferentes
`-eq -ne -gt -ge -lt -le`	Comparações numéricas
`-e arq`, `-f arq`, `-d dir`	Existe / é arquivo comum / é diretório

Correções do livro

Os exemplos da fonte trazem falhas comuns de digitação: if[ e ["$numero" sem espaços (o colchete é um comando e exige espaços), echo $date onde a variável é data, $nome-da-musica (hífen não é permitido em nome de variável) e find -l no lugar de fc -l. Sempre teste os scripts; use set -euo pipefail e aspas em variáveis ("$var") como boa prática (complemento).

Redes no Linux¶

Para um servidor acessar a internet são necessárias três configurações:

Endereço IP e máscara compatíveis com a LAN (ex.: 192.168.1.75/24).
Gateway (roteador de saída para a rede externa/WAN).
DNS para resolver nomes em IPs.
IPv4: 4 octetos + máscara que separa a parte da rede da parte do host. Classes: A (/8, 255.0.0.0), B (/16) e C (/24, 255.255.255.0). A interface loopback (lo, 127.0.0.1) existe em toda máquina e serve à comunicação local. Teoria de TCP/IP e do modelo OSI em Redes.
TCP é orientado a conexão (handshake); DNS traduz nomes em IPs (não é obrigatório para a internet funcionar, só prático).
Teste de conectividade: ping 8.8.8.8 funciona e ping google.com não → problema de DNS.

Tarefa	Livro (obsoleto)	Hoje
Ver interfaces/IPs	`ifconfig -a`	`ip a`
IP temporário (perde-se no reboot)	`ifconfig eth0 192.168.1.75`	`ip addr add 192.168.1.75/24 dev eth0`
Gateway temporário	`route add default gw 192.168.1.1`	`ip route add default via 192.168.1.1`
Tabela de rotas	`route -n`	`ip route`
Portas/conexões	`netstat -pultan`	`ss -tulpn`

Configuração dinâmica x estática: a dinâmica (comandos acima) vale só até o reboot, útil em redes temporárias; a estática é gravada em arquivo e persiste.

Debian (antigo): /etc/network/interfaces (iface eth0 inet static + address, netmask, gateway).
Ubuntu 20.04+: Netplan (YAML, cuidado com a indentação) em /etc/netplan/*.yaml:

network:
  version: 2
  ethernets:
    enp0s3:
      addresses: [192.168.0.10/24]
      routes:
        - to: default            # Hoje: "gateway4" foi substituído por routes
          via: 192.168.0.1
      nameservers:
        addresses: [192.168.0.1, 8.8.8.8]

Aplique com sudo netplan apply. Outros arquivos: /etc/resolv.conf (servidores DNS, hoje gerenciado pelo systemd-resolved), /etc/hosts (nomes locais: IP, FQDN, hostname, apelido), /etc/hostname (nome da máquina; hostnamectl set-hostname altera de forma permanente).

Gerenciamento de pacotes e software¶

Um pacote reúne binários, bibliotecas e arquivos de configuração. O gerenciador de pacotes resolve as dependências automaticamente (baixa B e C quando se instala A) a partir de repositórios (/etc/apt/sources.list). No Debian/Ubuntu os pacotes são .deb e o gerenciador é o apt.

sudo apt update                    # atualiza a lista de pacotes (apt-get update)
sudo apt upgrade                   # atualiza os instalados; apt full-upgrade ~ dist-upgrade
apt search firefox                 # (apt-cache search)  apt show elinks (apt-cache show)
sudo apt install elinks
sudo apt remove elinks             # remove o programa, mantém configurações
sudo apt purge elinks              # remove inclusive as configurações
sudo apt autoremove                # remove dependências órfãs
sudo apt clean                     # limpa o cache em /var/cache/apt/archives

Ferramenta	Característica
dpkg	Base do sistema Debian: instala `.deb` locais (`dpkg -i`), lista (`dpkg -l`), status (`-s`), remove (`-r`); não resolve dependências
snap	Pacotes da Canonical com todas as dependências embutidas e repositório próprio (`snap install/remove/refresh/list`)
Flatpak	Aplicativos em *sandbox, sobre um runtime* compartilhado; `flatpak install/run/update/uninstall`, com repositórios (`flathub`) e instalação por usuário (`--user`) ou sistema
Código-fonte	`./configure` (verifica dependências e gera o `Makefile`), `make`, `make install`; remover com `make uninstall`. Requer `build-essential`

Boa prática: teste em máquina virtual e use apenas repositórios confiáveis em produção.

Módulos e compilação do kernel¶

O desenvolvedor compila um kernel básico e coloca funcionalidades específicas (suporte a NTFS, USB, placas de rede) em módulos carregados sob demanda.

lsmod                      # módulos carregados (coluna "Used by" mostra dependências)
modinfo vfat               # informações e dependências de um módulo
sudo modprobe vfat         # carrega o módulo (e as dependências)
sudo modprobe -r vfat      # descarrega (e as dependências sem uso)
sudo insmod arquivo.ko / rmmod modulo    # baixo nível, sem resolver dependências
ls /lib/modules/$(uname -r)/kernel       # módulos disponíveis

Um módulo só pode ser removido se ninguém depender dele. Compilar um kernel (raramente necessário, por exemplo para suportar hardware novo): baixar de kernel.org, instalar build-essential libncurses5-dev, descompactar em /usr/src, make menuconfig (gera .config), make (imagem e módulos), make modules_install, make install, gerar o initrd (mkinitramfs) e update-grub.

Discos: partições, sistemas de arquivos e montagem¶

Partição: divisão do disco que recebe um sistema de arquivos. Com a tabela MBR: até 4 partições primárias, ou 3 primárias + 1 estendida (contêiner, não guarda dados) com várias lógicas (/dev/sda5 em diante). Complemento: a tabela GPT (UEFI) remove esse limite e suporta discos grandes.
Sistemas de arquivos: ext4 (padrão no Linux), XFS, Btrfs, ZFS; FAT32/NTFS (Windows); HFS+ (Mac). Uma partição tem um sistema de arquivos.
Particionadores: fdisk (interativo por teclas: p lista, n nova, d apaga, t tipo, w grava), cfdisk (menu) e parted.

sudo fdisk /dev/sdb                  # particiona o 2º disco
sudo mkfs.ext4 /dev/sdb1             # cria o sistema de arquivos (mkfs.ntfs requer ntfs-3g)
sudo mkdir /mnt/backup               # ponto de montagem (um diretório)
sudo mount -t ext4 /dev/sdb1 /mnt/backup
sudo umount /mnt/backup
df -h                                # uso das partições montadas
du -sh /var/log                      # tamanho de um diretório
lsblk                                # complemento: árvore de discos e partições

Montagem automática no boot: /etc/fstab. Uma linha por montagem:

/dev/sdb1   /mnt/backup   ext4   defaults,user   0   2
# dispositivo  ponto       tipo   opções     dump  fsck (1 para /, 2 para as demais, 0 = não checa)

Complemento: prefira identificar a partição por UUID (blkid), que não muda como /dev/sdb pode mudar. Teste com sudo mount -a antes de reiniciar para não travar o boot.

Memória swap¶

Área de disco usada como extensão da RAM quando ela se esgota (área de troca): mkswap /dev/sdb2, swapon /dev/sdb2, swapon -s ou cat /proc/swaps para listar e swapoff para desativar.

Quotas de disco¶

Limitam o espaço por usuário ou grupo na partição (apt install quota). Passos: adicionar as opções usrquota,grpquota ao /etc/fstab, remontar, e usar edquota -u usuario (ou -g grupo) para definir os limites soft (aviso; pode ser excedido por um período de graça, edquota -t) e hard (teto absoluto), preferencialmente em blocos (KB) em vez de nº de arquivos (inodes). repquota -a mostra o relatório; QUOTAUSER em /etc/adduser.conf replica a quota para novos usuários.

RAID¶

Definição: RAID

Redundant Array of Independent Disks: combina vários discos em um único volume lógico para ganhar desempenho, redundância ou ambos. Pode ser por software (o Linux gerencia, flexível) ou por hardware (controladora dedicada, mais rápida, mas ela vira um SPOF — ponto único de falha).

Nível	Técnica	Discos mín.	Redundância	Capacidade útil
RAID 0	Striping (divide os dados entre os discos)	2	Nenhuma	100%
RAID 1	Mirroring (espelha)	2	Tolera a falha de 1 disco	50%
RAID 5	Striping com paridade distribuída	3	Tolera a falha de 1 disco	n − 1 discos
RAID 6	Paridade dupla	4	Tolera a falha de 2 discos	n − 2 discos
RAID 10	Espelhos (1) combinados em striping (0)	4	1 disco por espelho	50%

RAID não é backup

RAID dá redundância (o servidor continua de pé se um disco falhar), mas não protege contra exclusão acidental, corrupção, ransomware ou perda do servidor. Backup é uma cópia separada para restauração futura.

Com o mdadm:

sudo mdadm --create /dev/md1 --level=1 --raid-devices=2 /dev/sdd1 /dev/sde1
sudo mdadm --create /dev/md2 --level=5 --raid-devices=3 --spare-devices=1 /dev/sdh1 /dev/sdi1 /dev/sdj1 /dev/sdk1
cat /proc/mdstat                         # estado em tempo real
sudo mdadm --detail /dev/md2
sudo mdadm /dev/md2 --fail /dev/sdh1     # simula falha (o disco spare assume)
sudo mdadm /dev/md2 --remove /dev/sdh1   # remove o disco com falha
sudo mdadm /dev/md2 --add /dev/sdh1      # adiciona um novo (vira reserva)
sudo mkfs.ext4 /dev/md1                  # depois: sistema de arquivos e montagem

Para persistir a configuração, grave-a em /etc/mdadm/mdadm.conf (mdadm --detail --scan).

LVM (Logical Volume Manager)¶

O LVM cria uma camada de abstração sobre os discos para redimensionar volumes sem parar o sistema: em vez de decidir o tamanho das partições na instalação, você cresce sob demanda.

Camada	Comando	Descrição
PV (Physical Volume)	`pvcreate /dev/sdb1`, `pvdisplay`	Partições/discos entregues ao LVM
VG (Volume Group)	`vgcreate storage /dev/sdb1 /dev/sdc1`, `vgextend storage /dev/sde1`, `vgdisplay`	"Pool" de espaço formado pelos PVs
LV (Logical Volume)	`lvcreate -L 3G -n lv_storage storage`, `lvextend -L +2G ...`, `lvdisplay`	"Partições" lógicas criadas a partir do VG

sudo mkfs.ext4 /dev/storage/lv_storage
sudo mount /dev/storage/lv_storage /mnt/lv_storage

# Crescer: adiciona um disco ao VG, aumenta o LV e ajusta o sistema de arquivos
sudo vgextend storage /dev/sde1
sudo lvextend -L +2G /dev/storage/lv_storage
sudo resize2fs /dev/storage/lv_storage      # (complemento: com ext4 dá para crescer montado; "lvextend -r" faz os dois passos)

flowchart TB
    D1["/dev/sdb1"] --> PV1["PV"]
    D2["/dev/sdc1"] --> PV2["PV"]
    D3["/dev/sde1"] --> PV3["PV"]
    PV1 --> VG["VG storage"]
    PV2 --> VG
    PV3 --> VG
    VG --> LV["LV lv_storage"]
    LV --> FS["ext4 montado em /mnt/lv_storage"]

SSH e SFTP¶

Definição: SSH

Secure Shell: protocolo que abre um canal criptografado entre dois computadores para executar comandos remotos, transferir arquivos e criar túneis. É a forma padrão de administrar servidores (porta 22).

sudo apt install openssh-server          # servidor; configuração: /etc/ssh/sshd_config
ssh usuario@192.168.1.10                 # conecta; ssh -p 2222 para outra porta
scp arquivo.txt usuario@host:/destino    # copia pelo SSH; -r diretórios; -P (maiúsculo) escolhe a porta
scp usuario@host:/arquivo ./local        # baixa do servidor
sudo systemctl restart ssh               # aplica mudanças no sshd_config

Autenticação por chaves assimétricas¶

Gera-se um par de chaves: a privada (fica só com você, protegida por passphrase) e a pública (instalada no servidor). Só quem tem a privada correspondente consegue entrar — sem enviar senha pela rede.

ssh-keygen -t ed25519 -C "meu-notebook"       # o livro usa "-t rsa"; ed25519 é a escolha moderna
ssh-copy-id -i ~/.ssh/id_ed25519.pub usuario@192.168.1.10
ssh usuario@192.168.1.10                       # entra sem senha (ou só com a passphrase)

SFTP¶

SFTP (SSH File Transfer Protocol) transfere arquivos sobre o SSH, com criptografia e uma só porta (22) — ao contrário do FTP, que trafega senhas em texto puro e usa vários canais. Para um usuário só de SFTP: criar o grupo (groupadd sftpusers) e o usuário sem shell (useradd -g sftpusers -s /sbin/nologin ...), usar Subsystem sftp internal-sftp e, no sshd_config:

Match Group sftpusers
    ChrootDirectory /sftp/%u
    ForceCommand internal-sftp

(O diretório do chroot deve pertencer ao root e não ser gravável pelo usuário; crie um subdiretório gravável dentro dele.)

Hardening: endurecendo o servidor¶

Hardening é buscar ameaças e aplicar correções para reduzir a superfície de ataque.

Medida	Como
Privilégios mínimos	Use `sudo` em vez de logar como root; `Defaults timestamp_timeout=0` faz o sudo sempre pedir a senha
SSH	`PermitRootLogin no`, `LoginGraceTime` curto, `Banner /etc/issue.net` (aviso legal); complemento: desabilitar login por senha (`PasswordAuthentication no`) e usar chaves, limitar usuários (`AllowUsers`) e usar `fail2ban`. Mudar a porta (ex.: 22 → 53000) só reduz o "ruído" de varreduras (segurança por obscuridade), não substitui as medidas anteriores
Senhas fortes	`pwgen 10 4` gera senhas; `chage -l/-m/-E usuario` define validade e troca; `passwd -l/-u` bloqueia/desbloqueia a conta; procurar contas sem senha em `/etc/shadow`
Portas e serviços	`nmap -sV localhost` e `ss -tulpn` para achar serviços desnecessários e desativá-los (`systemctl disable --now servico`)
Atualizações	`apt update && apt upgrade` com frequência (e atualizações automáticas de segurança)
Auditoria	Log de `su` (`SULOG_FILE` em `/etc/login.defs`), `tail -f` nos logs
cron	Restringir quem agenda tarefas com `/etc/cron.allow` e `/etc/cron.deny`
Superfície	Sem interface gráfica no servidor (`systemctl set-default multi-user.target`); desativar USB de armazenamento (`install usb-storage /bin/true` em `/etc/modprobe.d/`); desativar IPv6 se não for usado (`sysctl`); ignorar ICMP/broadcast (`net.ipv4.icmp_echo_ignore_*`)
Firewall	Complemento: `ufw` ou `nftables`/`iptables` com política "negar tudo, liberar só o necessário"

Teoria de segurança, criptografia e autenticação em Segurança.

Serviços de rede¶

NFS: compartilhamento entre máquinas Linux¶

NFS (Network File System) monta um diretório remoto como se fosse local.

# Servidor
sudo apt install nfs-kernel-server
# /etc/exports (quem acessa e com que opções):
#   /storage/juliano 192.168.1.2(rw,root_squash,no_subtree_check,async)
sudo exportfs -r                  # relê o exports
showmount -e localhost            # confere o que está exportado

# Cliente
sudo apt install nfs-common
sudo mount -t nfs 192.168.1.1:/storage/juliano /mnt/storage
# /etc/fstab: 192.168.1.1:/storage/juliano /mnt/storage nfs defaults,soft 0 0

Opção do export	Efeito
`ro` / `rw`	Somente leitura / leitura e escrita
`root_squash` (padrão)	O root do cliente não tem privilégios de root no compartilhamento (mais seguro)
`no_root_squash`	O root do cliente age como root no servidor (use só se for imprescindível)
`async`	Responde antes de gravar no disco: mais rápido, com risco em caso de queda

Samba: integração com Windows¶

O Samba implementa o protocolo SMB/CIFS do Windows (por engenharia reversa; o nome vem de "SMB"): compartilha arquivos e impressoras entre Linux e Windows e, na versão 4, pode atuar como controlador de domínio do Active Directory (DC) ou membro de domínio.

Pré-requisitos: /etc/hosts e /etc/hostname com o nome do servidor e o domínio, instalação de samba krb5-user winbind ... (inclui Kerberos, protocolo de autenticação).
Provisionar o domínio: parar smbd, nmbd e winbind, guardar o smb.conf original e rodar samba-tool domain provision --use-rfc2307 --interactive (informa realm, domínio, papel dc, DNS interno e forwarder, senha forte do Administrator); ativar samba-ad-dc; apontar o DNS da máquina para si mesma; copiar o krb5.conf gerado.
Administração: samba-tool user add|list, samba-tool group add|addmembers|listmembers; compartilhamentos no smb.conf ([publico] path=... read only=No browseable=Yes); as permissões finas são ajustadas pelo Windows (aba Segurança).
Teste: smbclient -L localhost -U Administrator e host -t A dominio.intra.

Apache e a pilha LAMP¶

Apache HTTP Server (1995, licença livre) serve páginas web; é parte da pilha LAMP (Linux, Apache, MySQL, PHP).

sudo apt install apache2             # DocumentRoot: /var/www/html
sudo apt install php libapache2-mod-php php-mysql mysql-server    # PHP atual (o livro usa php5, obsoleto)
sudo systemctl restart apache2

Para um CMS como o WordPress: criar um banco e um usuário com permissões só nesse banco (CREATE DATABASE, CREATE USER ... IDENTIFIED BY '<senha forte>', GRANT ALL PRIVILEGES ON banco.* TO ...; é o root do MySQL, não o do sistema), baixar o WordPress para /var/www/html e seguir o instalador. Hoje, o mais comum é usar o Nginx e/ou contêineres (Docker); conceitos de banco em SQL.

Squid: servidor proxy¶

Um proxy é um intermediário entre os clientes e a internet: filtra conteúdo e mantém um cache (economiza banda). O Squid (/etc/squid/squid.conf, porta padrão 3128) trabalha com ACLs (Access Control Lists) avaliadas em ordem — a primeira regra que casa vale, então a ordem importa:

acl localnet src 172.16.10.0/24                          # rede dos clientes
acl liberados dstdomain -i "/etc/squid/liberados.txt"    # domínios liberados (um por linha, com ponto inicial)
acl palavras_bloqueadas url_regex -i "/etc/squid/palavras_bloqueadas.txt"

http_access allow localnet liberados
http_access deny  localnet palavras_bloqueadas
http_access allow localnet
maximum_object_size 800 MB
cache_dir ufs /var/spool/squid 10000 128 256             # 10 GB de cache

Comandos: squid -z (cria o cache), squid -k parse (valida a configuração), squid -k reconfigure (recarrega sem reiniciar). Para obrigar a navegação pelo proxy, o firewall do gateway bloqueia o encaminhamento direto das portas 80/443 (iptables -A FORWARD -p tcp --dport 80 -j DROP).

flowchart LR
    C["Clientes (LAN)"] -->|"porta 3128"| P["Squid: ACLs + cache"]
    P --> I(("Internet"))
    C -. "80/443 bloqueadas no firewall" .-> I

Boas práticas de administração¶

Documente cada passo e versione arquivos de configuração (/etc) — arquivos de texto simples são fáceis de replicar (hoje, via ferramentas como Ansible).
Faça backup antes de alterar (cp smb.conf smb.conf.bkp) e teste em máquina virtual.
Evite trabalhar sempre como root; use sudo.
Dimensione discos com LVM e use RAID + backup (não um no lugar do outro).
Atualize o sistema e monitore logs, processos e portas.
Em nuvem e contêineres, o mesmo conhecimento se aplica: a imagem Docker é uma distribuição mínima e os serviços são gerenciados pelo systemd/orquestrador (SRE).

Perguntas comuns de entrevista (resumo)¶

Pergunta	Resposta curta
Qual a diferença entre Linux e GNU/Linux?	Linux é o kernel (Torvalds, 1991); GNU são as ferramentas do sistema; juntos formam o GNU/Linux. Uma distribuição empacota tudo
O que há em `/etc`, `/var` e `/proc`?	Configurações; dados variáveis e logs; informações do kernel em um sistema de arquivos virtual
`su` x `sudo`?	`su` troca de usuário (exige a senha dele); `sudo` executa um comando com privilégios, segundo o `sudoers`
O que é um ponto de montagem e para que serve o `fstab`?	Diretório pelo qual se acessa uma partição; o `fstab` define as montagens automáticas no boot
Diferença entre `apt` e `dpkg`?	O `apt` baixa dos repositórios e resolve dependências; o `dpkg` instala `.deb` locais sem resolvê-las
RAID 1 x RAID 5?	Espelhamento (50% de capacidade, tolera 1 falha) x paridade distribuída (n−1 discos úteis, tolera 1 falha); nenhum substitui backup
Para que serve o LVM?	Criar e redimensionar volumes lógicos sobre vários discos sem parar o sistema
Como proteger o SSH?	Chaves em vez de senha, sem login de root, usuários limitados, `fail2ban`, firewall, atualizações
FTP x SFTP?	O FTP não criptografa e usa vários canais; o SFTP roda sobre o SSH (porta 22) e é criptografado
Como diagnosticar "sem internet"?	`ip a` (IP), `ip route` (gateway), `ping 8.8.8.8` (conectividade), `ping nome` (DNS), `ss -tulpn` (portas)