Unixnomicon: um glossário do kernel aos containers
Um glossário sobre Unix e sistemas Unix-like 'feito nas coxa', com foco em Linux, para entender os termos que aparecem em tutoriais, logs, man pages e discussões técnicas.
O primeiro problema de aprender Linux não é o terminal. É o vocabulário.
Você instala uma distribuição, alguém chama tudo de Linux, outra pessoa corrige dizendo que Linux é só o kernel, um tutorial manda montar um filesystem, o log reclama de uma unit, o Docker fala de namespaces e, quando você percebe, está tentando entender cinco camadas diferentes com palavras que parecem ter sido escolhidas para confundir iniciantes.
Este texto é um glossário para consultar quando algum termo aparecer num tutorial, numa mensagem de erro, numa discussão técnica ou naquela configuração copiada às duas da manhã que “funciona até parar de funcionar”. Não é uma enciclopédia de todos os comandos existentes. A ideia é explicar os conceitos que realmente conectam as peças do sistema.
A ordem não é alfabética. Ela acompanha a forma como o Linux é montado: hardware, kernel, userspace, processos, arquivos, shell, pacotes, rede, segurança e isolamento. Os termos mais básicos aparecem primeiro; os avançados vêm quando já existe contexto suficiente para não parecer magia negra.
Linux não é uma coisa só
Quando alguém diz “Linux”, pode estar falando do kernel, de uma distribuição inteira, de um servidor, de um desktop ou de uma família de sistemas. Tecnicamente são coisas diferentes. Na conversa cotidiana, quase ninguém para para especificar, e tudo bem, desde que você saiba qual camada está sendo discutida.
Linux
Em sentido estrito, Linux é o kernel iniciado por Linus Torvalds em 1991. Ele gerencia CPU, memória, processos, dispositivos, rede, sistemas de arquivos e a comunicação entre programas e hardware.
No uso cotidiano, “Linux” também virou o nome informal dos sistemas construídos ao redor desse kernel. A precisão importa quando a discussão é técnica; em conversa normal, corrigir toda pessoa que fala “Linux” costuma produzir mais barulho do que conhecimento.
GNU/Linux
GNU/Linux é o nome usado para destacar que muitas distribuições combinam o kernel Linux com ferramentas e bibliotecas do projeto GNU, como Bash, glibc e Coreutils.
A ressalva importante é que nem todo sistema baseado no kernel Linux usa esse conjunto. Alpine Linux, por exemplo, é conhecido por usar musl e BusyBox; Android usa o kernel Linux, mas tem um userspace bastante diferente de uma distribuição tradicional. “GNU/Linux” é correto para muitos sistemas, não uma fórmula universal para qualquer coisa que inicialize o kernel.
Distribuição ou distro
Uma distribuição combina o kernel com instalador, gerenciador de pacotes, repositórios, bibliotecas, serviços, configurações padrão e políticas de manutenção.
Debian, Fedora, Ubuntu, Arch Linux, openSUSE e Alpine não são apenas “temas diferentes”. Elas tomam decisões diferentes sobre atualização, empacotamento, estabilidade, segurança, init, versões de bibliotecas e responsabilidade do usuário.
Kernel
O kernel é o núcleo privilegiado do sistema. Aplicações comuns não acessam hardware diretamente; elas pedem ao kernel operações como abrir arquivos, criar processos, reservar memória ou enviar dados pela rede.
A documentação oficial do kernel é enorme porque “o kernel” não é um bloco simples. Ele reúne subsistemas de escalonamento, memória virtual, rede, drivers, VFS, segurança, virtualização e muito mais.
Userspace
Userspace é tudo que roda fora do espaço privilegiado do kernel: shells, serviços, bibliotecas, servidores, ambientes gráficos e aplicações.
Essa separação é uma das fronteiras mais importantes do sistema. Um navegador travando normalmente derruba o navegador. Um erro grave dentro do kernel pode comprometer ou parar a máquina inteira.
System call ou syscall
Uma system call é uma entrada controlada do userspace para o kernel. openat(), read(), write(), fork(), execve() e mmap() são exemplos.
Quando você executa cat arquivo.txt, o cat não “lê o disco” sozinho. Ele solicita ao kernel que abra e leia o arquivo. Ferramentas como strace permitem observar essa conversa, o que é extremamente útil quando um programa falha sem explicar direito o motivo.
Módulo do kernel
Um módulo é um trecho de código que pode ser carregado ou removido do kernel em tempo de execução. Muitos drivers, filesystems e recursos opcionais são distribuídos dessa forma.
lsmod lista módulos carregados e modprobe carrega ou remove módulos respeitando dependências. Módulo não é sinônimo de driver, embora muitos drivers sejam módulos.
Driver
Driver é o código que permite ao sistema controlar um dispositivo ou uma classe de dispositivos. Ele pode estar compilado diretamente no kernel, carregado como módulo ou, em alguns casos, ter partes no userspace.
Quando uma placa “não funciona no Linux”, o problema real pode estar no driver, no firmware, na versão do kernel, na configuração do dispositivo ou no suporte incompleto do fabricante. “Linux não reconheceu” é apenas o resumo menos útil da história.
Firmware
Firmware é software executado pelo próprio dispositivo ou por controladores próximos ao hardware. Placas Wi-Fi, GPUs, SSDs e outros componentes frequentemente precisam de blobs de firmware carregados durante a inicialização.
O driver ensina o kernel a conversar com o dispositivo; o firmware ajuda o dispositivo a saber o que fazer. São peças relacionadas, mas diferentes.
Do botão de ligar até o seu shell
O boot parece simples enquanto funciona. Quando quebra, aparecem UEFI, GRUB, initramfs, kernel parameters, root filesystem, PID 1 e emergency shell no mesmo minuto. O fluxo abaixo reduz isso ao essencial.
BIOS e UEFI
BIOS e UEFI são firmwares da plataforma responsáveis pelas primeiras etapas da inicialização. Eles testam hardware, inicializam componentes básicos e localizam algo capaz de continuar o boot.
UEFI é o modelo moderno e trabalha com recursos como a EFI System Partition e Secure Boot. Ele não é “parte do Linux”; existe antes de qualquer kernel ser carregado.
Bootloader
O bootloader localiza e carrega o kernel, normalmente junto com o initramfs e parâmetros de inicialização. GRUB, systemd-boot e Limine são exemplos.
Em dual boot, o menu visível costuma ser responsabilidade do bootloader. Depois que o kernel assume o controle, o bootloader praticamente sai de cena.
Initramfs
Initramfs é um pequeno filesystem temporário carregado em RAM no início do boot. Ele contém ferramentas e módulos necessários para encontrar e montar o root filesystem real.
Criptografia de disco, LVM, RAID ou drivers que não estão embutidos no kernel podem depender dele. Um initramfs quebrado é uma forma eficiente de descobrir que a inicialização tinha muito mais etapas do que parecia.
Parâmetros do kernel
São opções entregues ao kernel pelo bootloader, como root=, quiet, loglevel=, nomodeset ou parâmetros específicos de drivers.
Eles alteram o comportamento do kernel desde o início. Por isso aparecem tanto em procedimentos de diagnóstico: algumas decisões precisam ser tomadas antes que o userspace exista.
Init e PID 1
Depois de preparar o sistema, o kernel inicia o primeiro processo do userspace. Esse processo recebe o PID 1 e tem responsabilidades especiais, como iniciar o restante do sistema e adotar processos órfãos.
init é o nome genérico desse papel. systemd é uma implementação; SysVinit, OpenRC e runit são outras. Tratar init e systemd como sinônimos apaga justamente a diferença mais importante entre eles.
systemd
systemd é um conjunto de componentes para inicialização e gerenciamento do sistema. Seu processo principal costuma ocupar o PID 1 e gerenciar units, dependências, serviços, sockets, mounts, timers, sessões e integração com cgroups.
Ele é mais do que “o programa que inicia serviços”, o que explica tanto sua utilidade quanto a quantidade de discussões que consegue produzir.
Unit
Unit é a unidade de configuração gerenciada pelo systemd. Existem units de serviço (.service), socket (.socket), montagem (.mount), timer (.timer), alvo (.target) e outros tipos.
systemctl status sshd.service consulta uma unit. O serviço executado por ela é outra coisa: a unit descreve como o systemd deve gerenciá-lo.
Serviço e daemon
Daemon é um processo que permanece em segundo plano oferecendo alguma função, como sshd, um servidor web ou um banco de dados. Serviço é um conceito de gerenciamento: algo que o sistema inicia, supervisiona e interrompe.
Muitos serviços executam daemons, mas os termos não são perfeitamente equivalentes. Uma unit pode rodar uma tarefa curta e terminar; um daemon também pode existir sem ser controlado pelo systemd.
Arquivos, diretórios e armazenamento
No Linux, quase tudo aparece dentro de uma única árvore iniciada em /. Discos diferentes, pseudo-filesystems do kernel, dispositivos e compartilhamentos de rede podem ser encaixados nessa árvore por montagem.
Diretório raiz /
/ é o topo da árvore de diretórios. Todo caminho absoluto começa nele.
Não confunda / com /root. O primeiro é a raiz do filesystem; o segundo é, por convenção, o diretório pessoal do usuário root. Uma barra muda bastante coisa.
FHS
O Filesystem Hierarchy Standard descreve a finalidade esperada de diretórios como /etc, /usr, /var, /bin e /sbin. Distribuições modernas nem sempre seguem cada detalhe da mesma forma, especialmente com a unificação de /usr, mas o padrão continua sendo um mapa útil.
A especificação do FHS ajuda a entender por que configurações ficam em /etc, dados variáveis em /var e interfaces do kernel aparecem em outros pontos.
Filesystem
Filesystem é a estrutura usada para organizar arquivos, diretórios e metadados em um dispositivo ou volume. ext4, XFS, Btrfs, FAT32 e tmpfs são exemplos.
O termo também pode se referir à árvore montada e visível pelo sistema. O contexto diz se a conversa é sobre o formato de armazenamento, a implementação ou o conjunto de arquivos acessível.
VFS
Virtual Filesystem é a camada do kernel que oferece uma interface comum para diferentes filesystems. Graças ao VFS, programas usam operações parecidas para trabalhar com ext4, XFS, tmpfs, NFS ou procfs.
A aplicação pede “abra este caminho”; o VFS encaminha a operação para a implementação correta. É uma abstração extremamente importante e quase invisível quando tudo funciona.
Partição, volume e dispositivo de bloco
Partição é uma divisão lógica de um dispositivo de armazenamento. Volume é um termo mais amplo e pode representar uma partição, um volume lógico do LVM, um array RAID ou outro dispositivo composto.
Dispositivo de bloco é a interface usada para armazenamento acessado em blocos, como /dev/nvme0n1 ou /dev/sda. Um filesystem normalmente é criado sobre um dispositivo de bloco ou volume, não “diretamente numa pasta”.
Montagem e ponto de montagem
Montar é anexar um filesystem à árvore de diretórios. O diretório onde ele aparece é o ponto de montagem.
mount /dev/sdb1 /mnt/dados
Depois desse comando, o conteúdo do filesystem em /dev/sdb1 fica acessível por /mnt/dados. A pasta não “vira o disco”; ela passa a ser a porta de entrada para aquele filesystem.
/etc/fstab
/etc/fstab descreve filesystems que podem ser montados automaticamente ou por regras predefinidas. É comum identificar volumes por UUID para evitar depender de nomes como /dev/sdb1, que podem mudar.
Um erro nesse arquivo pode atrasar ou interromper o boot. A velha tradição de editar configuração como root e descobrir o erro só na reinicialização continua firme.
Inode
Inode é uma estrutura de metadados usada por filesystems Unix-like. Ele registra informações como tipo, permissões, proprietário, timestamps e referências aos blocos de dados.
O nome do arquivo não fica “dentro do inode” da forma que muita gente imagina. Diretórios associam nomes a números de inode. Isso ajuda a entender hard links e por que um arquivo pode continuar existindo mesmo após um nome ser removido.
Hard link e link simbólico
Hard link é outro nome apontando para o mesmo inode. Link simbólico é um arquivo especial que guarda um caminho para outro arquivo ou diretório.
O comando ln arquivo copia cria um hard link. ln -s alvo link cria um link simbólico.
/dev
/dev contém device nodes: arquivos especiais que representam interfaces para dispositivos e alguns recursos do kernel.
/dev/null, /dev/zero, /dev/random, discos e terminais aparecem ali. Ler ou escrever nesses arquivos pode significar interagir com um driver, não com dados armazenados como num arquivo comum.
/proc
/proc é um pseudo-filesystem que expõe informações sobre processos e o estado do kernel. Diretórios como /proc/1234 representam processos, e arquivos como /proc/cpuinfo ou /proc/meminfo apresentam dados do sistema.
Ele não ocupa um “diretório real no disco” da forma tradicional. É uma interface gerada pelo kernel, documentada na documentação do procfs.
/sys
/sys normalmente monta o sysfs, uma interface estruturada para dispositivos, drivers, classes e objetos internos do kernel.
Ferramentas de gerenciamento de hardware e o udev usam essas informações. /proc e /sys às vezes parecem semelhantes, mas /sys foi projetado com uma organização mais explícita dos objetos do kernel.
/etc, /var, /run e /tmp
/etc guarda configuração do sistema. /var guarda dados variáveis e persistentes, como logs, filas e bancos de estado. /run contém estado volátil desde o boot atual. /tmp é espaço temporário e pode ser limpo automaticamente.
Saber essa diferença evita colocar dados importantes num diretório temporário ou arquivos mutáveis em locais que deveriam representar configuração estática.
Processos, usuários e permissões
Um sistema Linux em execução é uma árvore de processos disputando recursos sob regras do kernel. Usuários e grupos ajudam a definir identidade; permissões, capabilities e políticas adicionais limitam o que cada processo pode fazer.
Processo
Processo é uma instância de um programa em execução, com memória, descritores de arquivo, credenciais, estado e recursos associados.
O arquivo executável no disco não é o processo. O mesmo binário pode originar vários processos independentes, cada um com PID e estado próprios.
Thread
Thread é uma linha de execução dentro de um processo. Threads do mesmo processo normalmente compartilham memória e vários outros recursos, mas possuem estado de execução individual.
A distinção importa para desempenho, concorrência, depuração e sinais. Ferramentas podem mostrar apenas processos ou detalhar threads, dependendo das opções usadas.
PID, PPID e árvore de processos
PID é o identificador de um processo. PPID é o PID do processo pai.
Processos formam uma árvore porque novos processos geralmente nascem de outros. ps, pstree e /proc ajudam a visualizar essa relação. O PID é reutilizável: ele identifica um processo naquele momento, não uma entidade eterna.
fork() e exec()
Em sistemas Unix-like, um padrão clássico é criar um novo processo com fork() e substituir seu programa com execve() ou outra função da família exec.
Quando um shell executa um comando externo, normalmente prepara redirecionamentos, cria o processo e carrega o executável. É por isso que criação de processos, pipes e descritores de arquivo aparecem juntos em explicações mais profundas sobre shells.
Sinal
Sinal é uma notificação assíncrona enviada a um processo ou thread. SIGTERM pede encerramento; SIGKILL força o kernel a terminar o processo; SIGHUP, SIGINT, SIGSTOP e outros têm semânticas próprias.
O comando kill envia sinais. Apesar do nome, kill PID normalmente envia SIGTERM, não uma execução sumária. kill -9 virou martelo universal porque ignora qualquer chance de limpeza. Justamente por isso, não deveria ser a primeira tentativa.
Usuário root
root é o superusuário tradicional, normalmente com UID 0. Ele pode ultrapassar grande parte das verificações normais de permissão.
Isso não significa onipotência absoluta: políticas de segurança, namespaces, capabilities, mounts somente leitura e mecanismos do kernel ainda podem impor limites. Mesmo assim, executar tudo como root continua sendo uma ótima forma de transformar um erro pequeno em incidente.
sudo e su
sudo executa um comando com credenciais definidas por política, frequentemente como root. su inicia uma sessão ou shell como outro usuário.
sudo não é “virar root por alguns segundos” de forma mágica; é uma ferramenta de delegação e auditoria. A configuração vive em sudoers, e editar esse arquivo sem visudo é uma aposta desnecessária.
UID, GID e grupos
UID identifica um usuário; GID identifica um grupo. Para o kernel, nomes como kristyan são representações amigáveis de identificadores numéricos.
Um processo carrega credenciais de usuário e grupos, usadas nas decisões de acesso. Arquivos também armazenam proprietário e grupo por identificadores.
Permissões rwx
As permissões tradicionais definem leitura (r), escrita (w) e execução (x) para proprietário, grupo e outros.
Em diretórios, os significados mudam um pouco: leitura permite listar nomes, escrita permite alterar entradas e execução permite atravessar o diretório. Decorar chmod 777 sem entender isso é o equivalente Unix de remover a porta porque a chave emperrou.
umask
umask define quais bits de permissão devem ser removidos das permissões solicitadas na criação de arquivos e diretórios.
Ela não “atribui a permissão final” diretamente. A aplicação solicita um modo inicial e a máscara retira bits. Por isso a conta parece estranha até você entender que é uma máscara, não um valor de permissão comum.
ACL
Access Control Lists permitem regras de acesso mais específicas que o modelo simples de proprietário, grupo e outros.
Com ACLs, é possível conceder permissões a usuários ou grupos adicionais sem mudar o grupo principal do arquivo. getfacl e setfacl são as ferramentas mais comuns.
Capabilities
Linux capabilities dividem parte dos poderes tradicionalmente concentrados no root em permissões menores, como abrir portas privilegiadas ou administrar interfaces de rede.
Isso permite que um processo receba apenas o privilégio necessário, em vez de acesso irrestrito. A man page de capabilities mostra o tamanho real desse mecanismo e também por que “rodar como não-root” não encerra sozinho uma análise de privilégio.
Namespace
Namespace isola a visão que um grupo de processos tem de algum recurso do sistema. Existem namespaces de processos, mounts, rede, usuários, hostname, IPC, cgroups e tempo.
Eles são uma das bases dos containers: processos podem enxergar uma árvore de PIDs, interfaces de rede e pontos de montagem diferentes do host. A visão geral de namespaces conecta os diferentes tipos.
cgroup
Control groups organizam processos hierarquicamente e controlam ou contabilizam recursos como CPU, memória, I/O e quantidade de processos.
Namespaces mudam o que um processo enxerga; cgroups controlam quanto ele pode consumir. Containers costumam usar ambos. A documentação do cgroup v2 é a referência autoritativa para o modelo atual.
OOM killer
Quando o sistema não consegue satisfazer demandas de memória, o kernel pode escolher processos para encerrar e recuperar recursos. Esse mecanismo é conhecido como OOM killer.
Quando um serviço “morreu do nada”, procurar eventos de OOM em dmesg ou no journal é mais útil do que culpar imediatamente a aplicação. O processo pode ter sido vítima do estado global da máquina ou do limite de um cgroup.
Terminal, TTY e shell
A tela preta com texto é uma coleção de componentes. Terminal, shell e comando não são três nomes para a mesma coisa.
Terminal emulator
Um emulador de terminal é a aplicação gráfica que mostra texto, recebe teclado e oferece uma interface compatível com terminais. Alacritty, Kitty, GNOME Terminal, Konsole e WezTerm são exemplos.
Ele não interpreta cd, pipes ou variáveis. Quem faz isso é o shell executado dentro dele.
TTY e PTY
TTY é o nome histórico dado a terminais. PTY, ou pseudo-terminal, é o mecanismo usado para conectar programas modernos a uma interface que se comporta como terminal.
Multiplexadores como tmux, conexões SSH e emuladores gráficos usam pseudo-terminais. Muitos comportamentos estranhos de programas interativos dependem de eles detectarem ou não que estão ligados a um TTY.
Shell
Shell é o interpretador de comandos e linguagem de automação que conecta entrada do usuário a programas e recursos do sistema.
Bash, Zsh, fish, Dash e Nushell são shells diferentes. Eles podem compartilhar ideias e sintaxe, mas não são totalmente compatíveis.
Bash, Zsh e fish
Bash é amplamente usado e tem forte compatibilidade com o mundo Unix e scripts existentes. Zsh oferece recursos interativos avançados e uma linguagem própria. fish prioriza uma experiência interativa amigável, mas não tenta ser compatível com a sintaxe POSIX.
Escolher um shell interativo é preferência. Escrever scripts portáveis é outro problema. A referência do Bash é mais confiável do que adivinhar o comportamento por tentativa e erro.
Comando, executável e builtin
“Comando” é o que você pede ao shell para executar. Ele pode resolver para um executável externo, uma função, um alias, uma palavra reservada ou um builtin do próprio shell.
cd geralmente é builtin porque precisa alterar o diretório do processo do shell. Um programa externo não conseguiria mudar permanentemente o diretório do processo pai.
type -a cd
type -a printf
type -a ls
type ajuda a descobrir o que o shell realmente executará.
PATH
PATH é uma variável com uma lista ordenada de diretórios onde o shell procura executáveis quando o comando não contém uma barra.
Se dois diretórios contêm um programa com o mesmo nome, vence o primeiro encontrado. Colocar . no início do PATH é conveniente até um arquivo malicioso com nome inocente aparecer no diretório atual.
Variável de ambiente
Variável de ambiente é um par nome-valor herdado por processos filhos. HOME, LANG, PATH, EDITOR e XDG_CONFIG_HOME são exemplos comuns.
Variáveis do shell nem sempre estão exportadas para o ambiente. export NOME=valor torna a variável disponível aos processos iniciados depois.
stdin, stdout e stderr
Processos Unix normalmente começam com três fluxos: entrada padrão (stdin, descritor 0), saída padrão (stdout, descritor 1) e saída de erro (stderr, descritor 2).
Essa convenção permite compor ferramentas sem cada programa precisar conhecer o próximo. É uma das ideias mais simples e produtivas do ambiente Unix.
Pipe
O pipe | conecta o stdout de um comando ao stdin do próximo.
cat arquivo.log | grep 'ERROR' | wc -l
O exemplo funciona, embora grep 'ERROR' arquivo.log | wc -l seja mais simples. Pipes são composição, não um concurso para usar o maior número de processos possível.
Redirecionamento
Redirecionamento muda a origem ou o destino dos descritores de arquivo.
comando >saida.log 2>erros.log
> sobrescreve, >> acrescenta, < fornece entrada e 2>&1 faz o descritor 2 apontar para o mesmo destino atual do descritor 1. A ordem importa porque o shell aplica redirecionamentos da esquerda para a direita.
Exit status
Todo processo termina com um código de saída. Por convenção, 0 indica sucesso e valores diferentes indicam falha ou condição especial.
O shell expõe o último código em $?. Operadores como && e || usam esse resultado para decidir se executam o próximo comando.
Glob e expressão regular
Glob é o padrão expandido pelo shell para nomes de arquivo, como *.log. Expressão regular é uma linguagem de padrões interpretada por ferramentas como grep, sed e várias linguagens de programação.
Eles se parecem, mas têm regras diferentes. *.log num shell não significa a mesma coisa que *.log numa regex. Misturar os dois é uma fonte inesgotável de comandos “quase certos”.
Coreutils
GNU Coreutils é um conjunto de utilitários fundamentais como ls, cp, mv, rm, cat, chmod, sort, cut, head, tail e wc.
Esses comandos não fazem parte do kernel. Em outros sistemas ou userspaces, podem vir de implementações diferentes, como BusyBox ou uutils, com diferenças de opções e comportamento.
grep, sed e awk
grep seleciona linhas por padrões. sed transforma fluxos de texto. awk é uma linguagem voltada a registros e campos.
Eles não são três versões do mesmo comando. Para buscas, comece com grep; para substituições e edições de fluxo, use sed; para lógica por colunas, cálculos e relatórios, awk costuma ser mais adequado.
find e xargs
find percorre árvores de diretórios e seleciona entradas por nome, tipo, data, tamanho e outros critérios. xargs transforma entrada em argumentos para outro comando.
Para nomes arbitrários, prefira interfaces seguras contra espaços e quebras de linha, como find ... -exec ... {} + ou a combinação -print0 com xargs -0.
Pacotes, repositórios e distribuições
Instalar software numa distribuição não é apenas baixar um executável. O sistema precisa saber de onde ele veio, quais arquivos pertencem ao pacote, quais dependências são necessárias e como atualizar ou remover tudo depois.
Pacote
Pacote é uma unidade de distribuição de software acompanhada de metadados. Ele pode conter binários, bibliotecas, configuração padrão, scripts de instalação e informações de dependência.
Um pacote não é necessariamente um único programa. Também pode representar biblioteca, documentação, headers, firmware ou metapacote.
Repositório
Repositório é uma fonte organizada de pacotes e metadados, normalmente assinada e mantida segundo as políticas da distribuição ou de um terceiro.
Adicionar um repositório concede confiança operacional a quem o mantém. O gerenciador de pacotes fará o trabalho com eficiência; ele não avaliará se a sua decisão foi sensata.
Gerenciador de pacotes
Gerenciador de pacotes instala, remove, consulta e atualiza pacotes. apt, dnf, pacman, zypper e apk são exemplos de interfaces de alto nível ou ferramentas centrais de suas distribuições.
Cada família tem camadas próprias. No Debian, por exemplo, apt e dpkg não ocupam exatamente o mesmo papel. No Arch, pacman gerencia pacotes oficiais e locais; o AUR envolve outro fluxo.
Dependência
Dependência é outro componente necessário para instalar, compilar ou executar um pacote. Ela pode ser obrigatória, opcional, de build, de runtime ou entrar em conflito com outra.
O trabalho mais valioso do gerenciador não é copiar arquivos. É manter um grafo coerente de versões e dependências sem transformar o sistema numa coleção artesanal de binários esquecidos.
Pacote binário e pacote-fonte
Pacote binário entrega arquivos já compilados para uma arquitetura e ambiente específicos. Pacote-fonte contém código e instruções para produzir os binários.
Distribuições podem aplicar patches, flags de compilação e políticas próprias. Por isso “a mesma versão upstream” não garante que dois pacotes de distribuições diferentes sejam idênticos.
.deb e .rpm
.deb e .rpm são formatos de pacote associados a famílias diferentes de distribuições. O formato do arquivo não define sozinho toda a experiência de gerenciamento.
APT, DNF e outras ferramentas trabalham com repositórios, resolução de dependências e políticas acima do formato básico. Instalar um arquivo isolado é apenas uma parte do sistema.
Rolling release e lançamento fixo
Rolling release atualiza continuamente os componentes da distribuição. Lançamentos fixos congelam uma base por versão e recebem correções ou atualizações controladas.
Rolling não significa automaticamente instável; fixed não significa automaticamente antigo ou seguro. A diferença real está na cadência, integração, testes, compatibilidade esperada e trabalho de manutenção transferido para o usuário.
AUR
O Arch User Repository é um repositório comunitário de receitas de build, principalmente arquivos PKGBUILD. Ele não é um repositório oficial de pacotes binários do Arch.
Helpers facilitam o processo, mas não transformam código da comunidade em software auditado pela distribuição. Eu já discuti esse risco no post sobre pacotes comprometidos no AUR. Conveniência continua não sendo uma cadeia de confiança.
Flatpak, Snap e AppImage
São modelos alternativos de distribuição de aplicações, com propostas diferentes.
Flatpak usa runtimes e sandboxing, com forte presença em aplicações desktop. Snap combina empacotamento, atualização e confinamento sob a infraestrutura da Canonical. AppImage prioriza executáveis portáteis e autocontidos, com menos integração central obrigatória.
Chamar os três de “pacote universal” ajuda numa conversa rápida, mas esconde diferenças importantes de atualização, permissões, distribuição, integração e confiança.
Rede e segurança
Rede em Linux também aparece como arquivos, processos, sockets, namespaces e regras do kernel. Segurança, por sua vez, não é uma opção isolada chamada “modo seguro”; é a soma de identidades, privilégios, políticas, atualizações e desenho operacional.
Interface de rede
Interface é o ponto lógico por onde o sistema envia e recebe pacotes. Pode representar hardware físico, loopback, bridge, túnel, VLAN ou interface virtual.
ip link lista interfaces. Nomes como eth0, enp4s0, wlan0, lo, docker0 e wg0 indicam origens e funções diferentes.
Endereço IP, rota e gateway
O endereço IP identifica uma interface dentro de uma rede. A tabela de rotas decide para onde enviar pacotes. O gateway é um próximo salto usado para alcançar outras redes.
Ter IP não garante acesso à internet. Ainda podem faltar rota, DNS, conectividade no gateway, regras de firewall ou resposta do destino.
DNS
DNS traduz nomes como example.com em registros, frequentemente endereços IP. Resolver um nome envolve bibliotecas, configuração local, caches e servidores recursivos.
Quando “a internet caiu”, testar um IP e depois um nome ajuda a separar conectividade de resolução. Culpar o DNS virou meme porque, com frequência irritante, o DNS realmente está envolvido.
Porta e socket
Porta é um número usado pelos protocolos de transporte para distinguir serviços num endereço. Socket é um endpoint de comunicação mantido pelo kernel.
Um processo “escuta na porta 8080” porque possui um socket associado àquele endereço e porta. Sockets também podem ser locais, como Unix domain sockets, sem usar IP.
SSH
SSH é um protocolo para acesso remoto seguro, execução de comandos, túneis e transferência de dados. OpenSSH é a implementação mais comum em sistemas Linux.
Autenticação por chave usa uma chave privada mantida pelo cliente e uma chave pública autorizada no servidor. A chave privada não deve ser enviada ao servidor nem compartilhada como se fosse senha de Wi-Fi.
Firewall e nftables
Firewall filtra ou transforma tráfego segundo regras. No Linux moderno, nftables é a infraestrutura principal para esse trabalho, embora ferramentas de alto nível como firewalld e UFW ofereçam interfaces mais amigáveis.
Abrir uma porta no firewall não inicia o serviço; iniciar o serviço não garante que a porta esteja acessível. São camadas distintas e a depuração precisa verificar ambas.
LSM
Linux Security Modules é a infraestrutura do kernel que permite implementar políticas adicionais de segurança. SELinux, AppArmor, Smack e Landlock se relacionam a esse mecanismo em níveis e usos diferentes.
Permissões Unix respondem “quem é o usuário e quais bits existem?”. Um LSM pode impor regras extras mesmo quando as permissões tradicionais permitiriam a ação.
SELinux e AppArmor
SELinux trabalha com rótulos, tipos e políticas de controle de acesso mandatório. AppArmor é conhecido por perfis fortemente baseados em caminhos.
Desativar o mecanismo porque uma aplicação foi bloqueada resolve o sintoma removendo a proteção inteira. O caminho correto é entender a negação, ajustar contexto ou perfil e preservar a política.
Hash, criptografia e assinatura
Hash produz um resumo de tamanho fixo e é usado para integridade, identificação e construção de outros mecanismos. Criptografia transforma dados para que apenas quem possui a chave adequada consiga lê-los. Assinatura digital permite verificar autoria e integridade.
Um checksum não torna um download confiável se o arquivo e o checksum vieram do mesmo servidor comprometido. Assinaturas e uma cadeia de confiança independente existem justamente para melhorar esse cenário.
Chave pública e chave privada
Criptografia assimétrica usa um par relacionado. A chave privada deve permanecer secreta; a chave pública pode ser distribuída.
Dependendo do algoritmo e protocolo, o par pode servir para assinatura, autenticação ou estabelecimento de segredo. “Criptografar com a chave privada” é uma simplificação ruim para explicar assinaturas e costuma gerar mais confusão depois.
Máquinas virtuais, containers e isolamento
Containers não são máquinas virtuais leves. Eles podem parecer semelhantes do ponto de vista operacional, mas o isolamento acontece em camadas diferentes.
Máquina virtual
Máquina virtual apresenta hardware virtual a um sistema operacional convidado. Esse convidado executa seu próprio kernel e userspace.
Ela oferece uma fronteira diferente da oferecida por containers e permite executar kernels distintos no mesmo host. O custo costuma ser maior em inicialização, memória e armazenamento.
Hipervisor, KVM e QEMU
Hipervisor é a camada que executa e isola máquinas virtuais. KVM adiciona suporte de virtualização ao kernel Linux. QEMU emula ou virtualiza hardware e frequentemente trabalha com KVM para acelerar execução próxima do hardware nativo.
Dizer apenas “uso QEMU” ou “uso KVM” pode esconder uma pilha com libvirt, virt-manager, firmware virtual, dispositivos paravirtualizados e redes virtuais.
Container
Container é um conjunto de processos isolados por recursos do kernel, normalmente com filesystem, rede, PIDs e limites próprios. Ele compartilha o kernel do host.
A imagem pode parecer uma instalação completa de uma distribuição, mas não existe um segundo kernel ali dentro. Essa diferença explica por que um container Linux precisa de um kernel Linux compatível no host.
Imagem e container
Imagem é um artefato imutável organizado em camadas, usado como base para criar containers. Container é a instância em execução, com estado adicional gravável e recursos associados.
A imagem é receita e conteúdo; o container é processo e estado. Apagar um container não deveria apagar dados importantes se esses dados foram colocados corretamente em volumes ou armazenamento externo.
Runtime
Runtime de container é o software que prepara e inicia o ambiente isolado. runc, crun, containerd, CRI-O, Docker e Podman aparecem em camadas diferentes dessa pilha.
“Docker” virou sinônimo popular de container, mas a implementação moderna envolve vários componentes e padrões. A marca é só uma parte da arquitetura.
OCI
Open Container Initiative mantém especificações para formatos de imagem e execução de containers. Isso permite interoperabilidade entre ferramentas e runtimes.
Compatibilidade OCI não significa que todas as ferramentas tenham o mesmo modelo operacional, interface, segurança padrão ou experiência de uso.
Docker e Podman
Docker oferece uma plataforma com daemon, API, CLI, build e distribuição de imagens. Podman prioriza um modelo sem daemon central obrigatório e suporta uso rootless de forma nativa.
A sintaxe parecida facilita migração, mas os detalhes de rede, compose, integração, sockets e ciclo de vida ainda merecem verificação. “É igual, só trocar o comando” funciona até atingir justamente a parte que não é igual.
chroot
chroot altera o diretório raiz aparente de um processo e seus filhos. É útil em recuperação de sistemas, instalação e ambientes de build.
Ele não é uma fronteira de segurança completa. Não oferece sozinho o conjunto de isolamento de namespaces, cgroups, capabilities e políticas usado por containers modernos.
Logs, diagnóstico e falhas
Conhecer os termos do sistema ajuda, mas o Linux fica realmente útil quando você consegue observar o que está acontecendo em vez de reiniciar e torcer.
Journal e journalctl
O systemd-journald coleta logs estruturados de serviços, kernel e outras fontes. journalctl consulta esses dados por unit, período, prioridade, boot e vários outros filtros.
journalctl -u sshd.service -b
Esse comando mostra mensagens da unit sshd.service no boot atual. É mais produtivo do que abrir arquivos aleatórios em /var/log esperando encontrar a pista certa.
dmesg
dmesg exibe mensagens do ring buffer do kernel. Ele é útil para drivers, dispositivos, boot, OOM, filesystems e eventos de baixo nível.
Em sistemas com journal, mensagens do kernel também podem ser consultadas com journalctl -k.
ps, top e htop
ps produz snapshots de processos. top mostra uma visão dinâmica de processos e recursos. htop oferece uma interface interativa mais amigável.
Nenhuma dessas ferramentas explica sozinha a causa de um problema. CPU alta, memória residente, espera de I/O e quantidade de threads são sinais que precisam de contexto.
lsof
lsof lista arquivos abertos por processos. Como sockets, pipes e dispositivos também são representados por descritores, ele ajuda a investigar portas, mounts ocupados e arquivos que continuam consumindo espaço após serem removidos.
O nome “list open files” parece modesto para uma ferramenta que resolve tantos mistérios operacionais.
strace
strace rastreia system calls e sinais. Ele mostra arquivos procurados, conexões tentadas, permissões negadas e operações que falharam.
É excelente para responder “o que esse programa está tentando fazer?”. Também gera muito ruído; filtrar chamadas e entender o contexto é melhor do que colar milhares de linhas num chat e esperar iluminação divina.
perf
perf é um conjunto de ferramentas de análise de desempenho integrado ao ecossistema do kernel. Ele pode coletar contadores de hardware, amostras de CPU, eventos e stacks.
É uma ferramenta de profiling, não apenas um monitor de uso. Quando o problema é “onde o tempo está sendo gasto?”, perf pode ir muito além de top.
Core dump
Core dump é um snapshot do estado de memória de um processo no momento de uma falha. Ele pode ser analisado com depuradores como GDB.
Em sistemas com systemd, coredumpctl ajuda a localizar e abrir dumps coletados. Naturalmente, dumps podem conter dados sensíveis e ocupar bastante espaço.
Kernel panic
Kernel panic acontece quando o kernel encontra uma condição fatal da qual não consegue se recuperar com segurança.
É diferente de uma aplicação travar. O kernel é a base comum do sistema; se ele perde a capacidade de manter invariantes fundamentais, parar pode ser menos perigoso do que continuar corrompendo estado.
Como consultar sem decorar tudo
Ninguém precisa memorizar este glossário inteiro. O objetivo é reconhecer as fronteiras: kernel não é distribuição, terminal não é shell, serviço não é necessariamente daemon, container não é VM, filesystem não é partição e root pode significar usuário, diretório ou privilégio dependendo da frase.
Quando um termo aparecer, comece pelas man pages:
man 1 comando
man 2 syscall
man 5 formato-de-arquivo
man 7 conceito
As seções também carregam informação. printf(1) é um comando; printf(3) é uma função de biblioteca. systemd.service(5) documenta o formato das units de serviço. A coleção Linux man-pages é uma das melhores portas de entrada para interfaces do kernel e da libc.
Depois, procure a documentação do projeto ou da distribuição. Arch Wiki é excelente, mas não substitui toda documentação upstream. Um tutorial pode ensinar o procedimento; a documentação costuma explicar o contrato, as limitações e o que acontece quando você sai do caminho feliz.
O vocabulário é parte da ferramenta
Aprender Linux não é decorar cinquenta comandos para parecer confortável diante de um terminal. É construir um modelo mental que permita prever onde cada problema pode estar.
Quando você entende as camadas, uma mensagem deixa de ser “o Linux quebrou”. Pode ser o bootloader não encontrando o kernel, o initramfs sem o módulo necessário, uma unit falhando, um processo bloqueado por permissões, um cgroup encerrando a aplicação por memória ou o DNS fazendo o que ele faz de melhor: virar suspeito antes mesmo de você terminar o café.
O sistema não fica menos complexo. Ele fica menos misterioso. E essa diferença é o que separa copiar comandos de realmente administrar uma máquina.