Linux e Unix (Comandos, Distribuições e Scripts)

O que mais cai

Do que trata o tópico

Este tópico ensina a família de sistemas operacionais que roda a maior parte dos servidores do mundo: o Unix, criado nos anos 1970, e o Linux, o sistema livre que segue o mesmo modelo. A apostila mostra como esses sistemas se organizam, os comandos que a prova pede, o sistema de permissões, os scripts do shell que automatizam tarefas e as distribuições, que são os pacotes completos que o usuário instala.

Base de referência

• POSIX.1 (IEEE Std 1003.1), edição de 2024: padrão que define a interface comum dos sistemas do tipo Unix (chamadas de sistema, shell e utilitários).
• FHS 3.0 (Filesystem Hierarchy Standard), da Linux Foundation: padrão que define a árvore de diretórios do Linux.

Conteúdo

Unix

Nos anos 1960, cada fabricante de computador tinha o seu próprio sistema operacional, e um programa escrito para uma máquina não rodava em outra. O Unix nasceu em 1969 nos Laboratórios Bell, da AT&T, criado por Ken Thompson e Dennis Ritchie, como um sistema simples para várias pessoas usarem o mesmo computador. Em 1973, o Unix foi reescrito na linguagem C, que Ritchie criou, e isso mudou a história do sistema.

Antes disso, os sistemas eram escritos em linguagem de montagem (assembly), presa a um processador. Com o Unix em C, bastava ter um compilador C para a nova máquina e recompilar o sistema. Essa qualidade é a portabilidade, e ela explica por que o Unix se espalhou por universidades e empresas. A AT&T licenciou o código para universidades, e daí saíram as variantes.

Características do Unix. O Unix é multiusuário, porque várias pessoas usam o mesmo sistema ao mesmo tempo, cada uma com a sua conta, os seus arquivos e as suas permissões. Ele é multitarefa, porque executa vários processos ao mesmo tempo, com o núcleo dividindo o processador entre eles. Ele é portável, por ser escrito em C. Ele também tem um sistema de arquivos hierárquico, uma árvore única que começa na raiz.

Arquitetura em camadas. O Unix tem três camadas principais. O núcleo (kernel) controla o hardware, gerencia memória, processos, arquivos e dispositivos e é a única parte com acesso direto ao hardware. O shell é o interpretador de comandos: ele lê o que o usuário digita, interpreta e pede ao núcleo que execute. Os utilitários são os programas pequenos que fazem cada tarefa (listar, copiar, buscar texto, ordenar).

O shell não é o núcleo. Essa troca é a confusão mais comum sobre a arquitetura: o shell é um programa comum, que roda como qualquer outro processo e pode ser trocado pelo usuário. Os programas pedem serviços ao núcleo por meio das chamadas de sistema (system calls), como abrir um arquivo, criar um processo ou ler do teclado.

Tudo é arquivo. No Unix, quase tudo aparece como um arquivo: o documento de texto, o diretório, o disco, o terminal, a impressora e até o canal entre dois processos. Os dispositivos ficam no diretório /dev, e um programa lê o disco ou o terminal com as mesmas operações que usa para ler um arquivo comum. Por isso as mesmas ferramentas servem para muitos fins.

Filosofia Unix. A filosofia Unix pede programas pequenos, que fazem uma coisa só e bem feita, e que se combinam entre si. A combinação usa o pipe (barra vertical, |), que liga a saída de um comando à entrada do comando seguinte. Cada programa lê texto e escreve texto, e por isso qualquer saída pode alimentar outro programa.

Entrada, saída e redirecionamento. Todo processo nasce com três canais abertos. A entrada padrão (stdin, descritor 0) vem do teclado; a saída padrão (stdout, descritor 1) vai para a tela; a saída de erro (stderr, descritor 2) também vai para a tela, mas por um canal separado. O redirecionamento troca o destino desses canais:

1. comando > arquivo grava a saída padrão no arquivo e apaga o conteúdo anterior.
2. comando >> arquivo acrescenta a saída ao fim do arquivo, sem apagar.
3. comando < arquivo usa o arquivo como entrada padrão.
4. comando 2> erros.txt grava só as mensagens de erro no arquivo.
5. comando > tudo.txt 2>&1 grava a saída e os erros no mesmo arquivo.
6. comando1 | comando2 entrega a saída do primeiro como entrada do segundo.

O arquivo especial /dev/null descarta tudo o que recebe. O comando ls /pasta 2> /dev/null mostra a listagem e esconde as mensagens de erro.

Exemplo resolvido: o arquivo servidores.txt tem uma linha por servidor, com nome, setor e salário separados por dois-pontos. O objetivo é contar quantos servidores há em cada setor.

ana:ti:7500
bruno:rh:5200
carla:ti:8100
davi:rh:4900
elis:ti:6100

cut -d: -f2 servidores.txt | sort | uniq -c

1. cut -d: -f2 usa o dois-pontos como separador e pega o 2º campo de cada linha: ti, rh, ti, rh, ti.
2. sort ordena as linhas: rh, rh, ti, ti, ti.
3. uniq -c junta as linhas iguais vizinhas e conta cada grupo.
4. Resultado: 2 rh e 3 ti.

O sort antes do uniq é necessário, porque o uniq só junta linhas iguais que estão uma ao lado da outra. Sem o sort, a saída teria cinco grupos de uma linha cada.

POSIX. Com tantas variantes, os programas pararam de rodar de uma variante para outra. O POSIX (Portable Operating System Interface) é o padrão do IEEE que define a interface comum: as chamadas de sistema, o comportamento do shell e dos utilitários. Um sistema compatível com POSIX roda os mesmos scripts e compila os mesmos programas com pouca ou nenhuma mudança.

Variantes do Unix. As variantes se dividem em dois grandes ramos históricos. O System V é o ramo da AT&T, e dele vêm o Solaris (Sun, depois Oracle), o AIX (IBM) e o HP-UX (HP). O BSD (Berkeley Software Distribution) é o ramo da Universidade da Califórnia em Berkeley, e dele vêm o FreeBSD, o OpenBSD e o NetBSD. O macOS, da Apple, tem base em BSD e tem a certificação oficial UNIX.

O nome UNIX, em maiúsculas, é marca registrada, e só usa o nome o sistema certificado pelo dono da marca (The Open Group). Os sistemas que seguem o modelo sem certificação são chamados de tipo Unix (Unix-like). O Linux é o exemplo principal: ele não descende do código da AT&T e foi escrito do zero, mas segue o mesmo modelo e o padrão POSIX.

Na prática, um órgão público migra um sistema de folha de pagamento de um servidor Solaris para um servidor Linux. Os scripts do shell que seguem o POSIX rodam sem mudança, porque os dois sistemas aceitam os mesmos comandos básicos e a mesma sintaxe. Já um script que usa uma opção própria do Solaris precisa de ajuste.

A diferença para o conceito vizinho: Unix é a família de sistemas e o padrão de projeto; Linux é um núcleo tipo Unix, livre, criado depois. O shell é o interpretador de comandos, e o núcleo é o gerente do hardware. O erro comum é dizer que o Linux é uma versão do Unix da AT&T ou que o shell faz parte do núcleo.

Como a banca cobra: a banca troca as funções do núcleo e do shell, pergunta o ramo de cada variante e pede o efeito de um redirecionamento ou de um pipe. A afirmação de que o Linux é um Unix certificado ou derivado da AT&T aparece com frequência.

Linux

Em 1991, o estudante finlandês Linus Torvalds escreveu um núcleo de sistema operacional para o seu computador pessoal e publicou o código para quem quisesse estudar e melhorar. Esse núcleo é o Linux. Ao mesmo tempo, o projeto GNU, criado por Richard Stallman em 1983, já tinha quase tudo de um sistema tipo Unix livre (compilador, shell bash, utilitários), mas faltava o núcleo. A junção dos dois formou um sistema completo, que por isso também é chamado de GNU/Linux.

O núcleo Linux é distribuído pela licença GPL (GNU General Public License), na versão 2. A GPL é uma licença de software livre: ela permite usar, estudar, alterar e redistribuir o programa, desde que a versão alterada e redistribuída mantenha a mesma licença e o código-fonte aberto. Esse efeito é chamado de copyleft. Software livre não quer dizer software grátis: uma empresa pode cobrar pela distribuição ou pelo suporte, desde que respeite a licença.

Núcleo monolítico modular. O núcleo Linux é monolítico, isto é, os gerenciadores de memória, de processos, de arquivos e os controladores de dispositivo (drivers) rodam todos no espaço do núcleo, num só programa. Ele também é modular, porque aceita carregar e descarregar partes (os módulos, como um driver novo) com o sistema em funcionamento. Os comandos lsmod (lista os módulos carregados) e modprobe (carrega um módulo) cuidam disso. O núcleo monolítico não é o mesmo que o micronúcleo, que deixa a maior parte dos serviços fora do núcleo.

Árvore de diretórios. O Linux tem uma árvore única, que começa na raiz (/). Não há letras de unidade, como no Windows: um disco, um pen drive ou uma partição aparecem como um diretório da árvore, depois de montados (comando mount). O padrão FHS define o papel de cada diretório:

Os registros do sistema ficam em /var/log. O /proc não ocupa espaço em disco: o núcleo gera o conteúdo na hora da leitura, e o arquivo /proc/cpuinfo mostra os dados do processador. O diretório /root não é a raiz: a raiz é o /, e o /root é só a pasta pessoal do administrador.

Caminhos. O caminho absoluto começa na raiz (/home/ana/relatorio.txt) e vale de qualquer lugar. O caminho relativo começa no diretório atual (docs/relatorio.txt). O ponto (.) é o diretório atual, os dois pontos (..) são o diretório pai e o til (~) é o diretório pessoal do usuário. Arquivos cujo nome começa com ponto (.bashrc) são ocultos e só aparecem com ls -a.

Comandos de arquivos e diretórios. O Linux diferencia maiúsculas de minúsculas: Relatorio.txt e relatorio.txt são dois arquivos diferentes, e o comando LS não existe. A tabela reúne os comandos básicos:

O rm não manda o arquivo para uma lixeira: a remoção é definitiva. O rmdir só remove diretório vazio, e para remover um diretório com conteúdo o comando é rm -r. O grep busca dentro dos arquivos (o conteúdo), e o find busca os arquivos (pelo nome e por outras propriedades); essa troca cai muito.

Usuários e grupos. Cada usuário tem um número de identificação, o UID, e o administrador, chamado root, tem UID 0. O root pode tudo no sistema, e por isso o uso diário é feito com conta comum. As contas ficam em /etc/passwd, as senhas criptografadas ficam em /etc/shadow, que só o root lê, e os grupos ficam em /etc/group.

O comando su troca de usuário e pede a senha do usuário de destino. O comando sudo executa um só comando como root e pede a senha do próprio usuário, desde que ele esteja autorizado no arquivo /etc/sudoers. Os comandos useradd, usermod e userdel criam, alteram e removem contas, e o comando passwd troca a senha.

Permissões. Cada arquivo tem um dono (usuário), um grupo e três conjuntos de permissões: do dono (u, de user), do grupo (g, de group) e dos outros (o, de others). Cada conjunto tem três permissões: leitura (r, de read), escrita (w, de write) e execução (x, de execute). O comando ls -l mostra tudo isso no início da linha.

-rwxr-x--- 1 ana ti 2048 out 15 09:00 relatorio.sh
drwxr-xr-x 2 ana ti 4096 out 15 09:00 docs

O primeiro caractere é o tipo: - para arquivo comum, d para diretório e l para link simbólico. Os nove seguintes são as permissões, em três grupos de três: dono, grupo e outros. Depois vêm o número de links, o dono (ana), o grupo (ti), o tamanho, a data e o nome.

No diretório, as permissões mudam de sentido. A leitura (r) permite listar os nomes dos arquivos; a escrita (w) permite criar, apagar e renomear arquivos dentro dele; a execução (x) permite entrar no diretório com cd e acessar os arquivos. Por isso quem tem escrita no diretório pode apagar um arquivo dele, mesmo sem permissão de escrita no próprio arquivo.

Notação octal. Cada permissão tem um valor: leitura vale 4, escrita vale 2 e execução vale 1. A soma dá um dígito de 0 a 7 para cada conjunto, e três dígitos descrevem o arquivo inteiro, na ordem dono, grupo e outros.

Exemplo resolvido: converter as permissões rwxr-x--- do arquivo relatorio.sh para octal e montar o comando chmod.

1. Dono rwx: 4 + 2 + 1 = 7.
2. Grupo r-x: 4 + 0 + 1 = 5.
3. Outros ---: 0 + 0 + 0 = 0.
4. Resultado: 750, e o comando é chmod 750 relatorio.sh.

O caminho inverso também cai. O valor 640 dá 6 = 4 + 2 (rw-) ao dono, 4 (r--) ao grupo e 0 (---) aos outros, isto é, rw-r-----. O valor 755 dá rwxr-xr-x, o padrão de programas e diretórios.

Notação simbólica. O chmod também aceita letras: quem (u, g, o ou a, de all, todos), a operação (+ acrescenta, - retira, = define exatamente) e a permissão. O comando chmod u+x script.sh dá execução ao dono, e o comando chmod go-w dados.txt retira a escrita do grupo e dos outros. A notação simbólica muda só o que é citado, e a octal define tudo de uma vez.

Exemplo resolvido: o arquivo notas.txt tem rw-rw-r-- e recebe o comando chmod u+x,g-w,o=r notas.txt.

1. Dono: rw- mais execução vira rwx (7).
2. Grupo: rw- menos escrita vira r-- (4).
3. Outros: =r define só leitura, r-- (4).
4. Resultado: rwxr--r--, isto é, 744.

Dono e grupo. O comando chown muda o dono (e o grupo, na forma chown ana:ti arquivo), e o comando chgrp muda só o grupo. Em regra, só o root muda o dono de um arquivo.

Máscara (umask). Quando um arquivo novo nasce, o sistema parte de uma permissão máxima e retira o que a umask manda. A permissão máxima é 666 para arquivos (sem execução) e 777 para diretórios. A umask indica as permissões que saem.

Exemplo resolvido: a umask é 027. Calcular as permissões de um arquivo novo e de um diretório novo.

1. Arquivo: o 666 perde o 0, o 2 e o 7 de cada posição. Dono 6 sem nada fica 6; grupo 6 sem escrita fica 4; outros 6 sem tudo fica 0. Resultado: 640 (rw-r-----).
2. Diretório: o 777 perde o mesmo. Dono 7; grupo 7 sem escrita fica 5; outros 0. Resultado: 750 (rwxr-x---).

Com a umask comum de 022, o arquivo nasce com 644 e o diretório com 755. A conta correta é retirar bits, e não subtrair os números: a umask 033 tira escrita e execução do grupo e dos outros, e o arquivo nasce com 644, e não com 633.

Permissões especiais. Há três bits especiais. O SUID (set user ID), num executável, faz o programa rodar com os poderes do dono do arquivo, e não de quem o executa: o comando passwd pertence ao root e tem SUID, e por isso um usuário comum consegue gravar a nova senha em /etc/shadow. O SGID (set group ID) faz o programa rodar com o grupo do arquivo e, num diretório, faz os arquivos novos herdarem o grupo do diretório. O sticky bit, num diretório, só deixa apagar um arquivo o dono dele, o dono do diretório ou o root.

Na listagem, o SUID aparece como s no lugar do x do dono, o SGID como s no lugar do x do grupo e o sticky bit como t no lugar do x dos outros. Em octal, os três ganham um quarto dígito à esquerda: SUID vale 4, SGID vale 2 e sticky vale 1. O diretório /tmp tem drwxrwxrwt (1777): todos escrevem nele, mas ninguém apaga o arquivo dos outros.

Links. Um link físico (hard link), criado com ln origem nome, é um segundo nome para o mesmo arquivo: os dois nomes apontam para o mesmo inode, a estrutura que guarda os dados e os atributos do arquivo. O arquivo só some do disco quando o último nome é apagado. O link físico não atravessa sistemas de arquivos diferentes e, em regra, não aponta para diretório.

Um link simbólico (symbolic link), criado com ln -s origem nome, é um arquivo pequeno que guarda o caminho do outro, como um atalho. Ele tem inode próprio, pode apontar para diretório e para outro sistema de arquivos, mas fica quebrado se o arquivo original for apagado. Na listagem, o link simbólico começa com l.

Processos. Cada programa em execução é um processo, com um número de identificação, o PID. O primeiro processo do sistema, o init ou o systemd, tem PID 1 e é o ancestral dos outros. O comando ps aux lista os processos, e o top mostra os processos em tempo real, com o uso de processador e de memória.

O comando kill envia um sinal a um processo pelo PID. Sem opção, o kill envia o sinal 15 (SIGTERM), que pede ao processo que termine e deixa ele fechar os arquivos. O comando kill -9 envia o SIGKILL, que encerra o processo na hora, sem chance de reação. O atalho Ctrl+C envia o sinal 2 (SIGINT) ao programa em primeiro plano, e o comando killall envia o sinal pelo nome do programa.

Um comando terminado em & roda em segundo plano e libera o terminal. O comando jobs lista as tarefas do terminal, o fg traz uma tarefa para o primeiro plano e o bg retoma em segundo plano uma tarefa parada com Ctrl+Z. O comando nohup mantém o processo vivo depois que o usuário sai do terminal.

Outros comandos de administração. O df -h mostra o espaço livre de cada sistema de arquivos montado, e o du -sh mostra quanto um diretório ocupa. O free -h mostra a memória usada e livre. O tar junta arquivos num só pacote: tar -czvf backup.tar.gz docs cria o pacote compactado com gzip, e tar -xzvf backup.tar.gz extrai. O uname -r mostra a versão do núcleo.

Inicialização e serviços. O computador liga e roda o firmware (BIOS ou UEFI), que chama o carregador de inicialização, em geral o GRUB. O GRUB carrega o núcleo, o núcleo monta a raiz e inicia o processo de PID 1. Nas distribuições atuais, esse processo é o systemd, que sobe os serviços; o comando systemctl inicia, para e consulta os serviços (systemctl status sshd).

Na prática, a servidora Bia, do setor de TI de uma prefeitura, precisa que só ela edite o script de backup, que o grupo ti possa ler e executar o script e que os outros usuários não vejam nada. Ela usa chown bia:ti backup.sh e depois chmod 750 backup.sh. Para ver se o serviço de banco de dados está ativo depois de reiniciar o servidor, ela usa systemctl status com o nome do serviço.

A diferença para o conceito vizinho: link físico é outro nome para o mesmo inode, e link simbólico é um atalho com inode próprio. O su troca de usuário com a senha do destino, e o sudo executa um comando como root com a senha do próprio usuário. O erro comum é calcular a umask por subtração simples e achar que o kill sem opção encerra o processo à força.

-rwsr-xr-x 1 root root 68208 mar 10 09:00 /usr/bin/passwd
drwxrwxrwt 15 root root 4096 out 15 08:00 /tmp
lrwxrwxrwx 1 ana ti 18 out 15 08:30 atalho -> /home/ana/dados

Como a banca cobra: a banca dá uma permissão em letras e pede o octal (ou o contrário), pergunta o diretório de cada tipo de arquivo, troca grep e find, su e sudo, link físico e simbólico, e o sinal 9 e o 15. A leitura da listagem do ls -l, com SUID e sticky bit, é cobrada com frequência.

Scripts em Unix e Linux

Um administrador que faz backup todo dia digita os mesmos comandos toda manhã, e um erro de digitação pode estragar o trabalho. O script de shell resolve esse problema: é um arquivo de texto com uma sequência de comandos que o shell executa em ordem, como se o usuário digitasse cada um. O script aceita variáveis, decisões e repetições, e por isso é uma linguagem de programação simples.

Shebang e execução. A primeira linha do script indica o interpretador, com os caracteres cerquilha e exclamação seguidos do caminho do shell, como #!/bin/bash. Essa linha é a shebang. Para executar o script pelo nome, ele precisa da permissão de execução (chmod +x backup.sh) e é chamado com o caminho, como ./backup.sh, porque o diretório atual em geral não está na lista de busca de comandos (a variável PATH).

O script também roda sem a permissão de execução, quando é passado como argumento ao shell: bash backup.sh. O comando source backup.sh (ou um ponto seguido do nome) executa o script no shell atual, e não num shell novo; por isso as variáveis criadas pelo script continuam valendo depois dele. A linha que começa com cerquilha, fora a shebang, é comentário e não é executada.

Variáveis. A variável é criada com o nome, o sinal de igual e o valor, sem espaços em volta do igual: nome=Ana. Com espaço (nome = Ana), o shell entende nome como um comando, e dá erro. Para usar o valor, o script escreve um cifrão antes do nome. Todas as variáveis do shell guardam texto; a conta aritmética usa a forma de duplos parênteses precedida de cifrão.

Uma variável criada no script só existe naquele shell. O comando export torna a variável visível para os programas que o script chama, e as variáveis de ambiente comuns são PATH (lista de diretórios onde o shell procura os comandos), HOME (diretório pessoal) e USER (nome do usuário).

Parâmetros especiais. O script recebe argumentos na linha de comando, e o shell guarda cada um num parâmetro. No código, cada parâmetro é escrito com cifrão antes do símbolo, como mostra o quadro:

$0   nome do script
$1   primeiro argumento ($2 é o segundo, e assim por diante)
$#   quantidade de argumentos
$@   todos os argumentos, cada um separado
$?   código de saída do último comando
$$   PID do shell que executa o script

O parâmetro especial que guarda o código de saída é o mais cobrado. Todo comando termina com um código de saída (exit status): 0 indica sucesso, e qualquer valor de 1 a 255 indica erro. O comando exit encerra o script com o código indicado, como exit 1. O 0 como sucesso é o contrário do costume de outras linguagens, em que 0 é falso.

Aspas. O shell trata cada tipo de aspas de um jeito. As aspas simples guardam o texto literal: nada dentro delas é substituído, nem a variável. As aspas duplas substituem as variáveis e os comandos, mas mantêm os espaços e impedem que o texto se parta em várias palavras. A substituição de comando, escrita com cifrão e parênteses ou com crases, troca o comando pela saída dele: a variável hoje recebe a data quando o script atribui a ela a substituição do comando date.

Testes e decisões. A estrutura if executa um bloco quando um comando termina com código 0. O comando de teste mais comum é o colchete ([ ... ], que é o mesmo comando test), com espaço depois do colchete de abertura e antes do de fechamento. O bloco termina com fi, que é o if ao contrário. A estrutura case escolhe entre vários padrões e termina com esac.

Os operadores de teste mudam conforme o tipo de dado:

O sinal = compara texto, e o -eq compara número. O sinal > dentro do colchete simples não compara número: ele é lido como redirecionamento e cria um arquivo.

Operadores && e ||. O operador && executa o segundo comando só se o primeiro der certo (código 0). O operador || executa o segundo só se o primeiro falhar. O comando mkdir dados && cd dados só entra no diretório se ele foi criado, e o comando ping -c1 servidor || echo "fora do ar" só mostra o aviso se o ping falhar. O ponto e vírgula (;) executa os dois comandos em sequência, sem olhar o resultado.

Laços. O laço for repete o bloco para cada item de uma lista. O laço while repete enquanto a condição dá código 0, e o laço until repete enquanto a condição falha. Os três têm o corpo entre do e done. O comando read lê uma linha do teclado e guarda numa variável.

Exemplo resolvido: o script soma.sh abaixo soma os argumentos recebidos e diz se o total é alto ou baixo. Ele é executado com ./soma.sh 3 4 5.

#!/bin/bash
total=0
for n in "$@"; do
  total=$((total + n))
done
echo "Argumentos: $#"
echo "Soma: $total"
if [ "$total" -gt 10 ]; then
  echo "alto"
else
  echo "baixo"
fi

1. A variável total começa com 0.
2. O laço for percorre todos os argumentos, um de cada vez: 3, 4 e 5.
3. A cada volta, a conta aritmética soma o argumento ao total: 0 + 3 = 3; 3 + 4 = 7; 7 + 5 = 12.
4. A primeira linha impressa traz a quantidade de argumentos: Argumentos: 3.
5. A segunda linha traz a soma: Soma: 12.
6. O teste -gt 10 compara 12 com 10 como números; 12 é maior, o teste termina com código 0 e o script imprime alto.

Agendamento com cron. O cron é o serviço que executa comandos em horários marcados. Cada usuário edita a sua tabela com crontab -e e lista com crontab -l. Cada linha tem cinco campos de tempo e o comando, nesta ordem: minuto (0 a 59), hora (0 a 23), dia do mês (1 a 31), mês (1 a 12) e dia da semana (0 a 7, em que 0 e 7 são domingo).

30 2 * * 1-5 /home/bia/backup.sh
0 */6 * * * /home/bia/limpa.sh

A primeira linha roda o backup às 2h30, de segunda a sexta. A segunda roda a limpeza no minuto 0 de cada 6 horas (0h, 6h, 12h e 18h). O asterisco quer dizer "qualquer valor", o hífen marca um intervalo e a barra marca o passo. O comando at agenda um comando para rodar uma vez só, e o cron agenda a repetição.

Na prática, a servidora Bia escreve um script que compacta a pasta de relatórios com tar, grava a saída num arquivo de registro com >> e termina com exit 1 se o tar falhar, testando o código de saída. Ela dá permissão de execução com chmod 750 e agenda o script no cron para as 2h30 dos dias úteis. Se a cópia falhar, o código de saída diferente de 0 aparece no registro, e ela vê o problema na manhã seguinte.

A diferença para o conceito vizinho: executar com ./script.sh ou bash script.sh cria um shell novo, e as variáveis somem no fim; executar com source roda no shell atual. As aspas simples guardam o texto literal, e as duplas substituem as variáveis. O erro comum é pôr espaço em volta do igual na criação da variável e achar que o código de saída 0 indica erro.

#!/bin/bash
cont=0
for arq in a.txt b.log c.txt d.txt; do
  case "$arq" in
    *.txt) cont=$((cont + 1)) ;;
  esac
done
echo "txt: $cont"
nome="prova"
echo 'nome' "$nome"

Como a banca cobra: a banca mostra um script curto e pede a saída, pergunta o significado dos parâmetros especiais e do código de saída, troca aspas simples e duplas, -eq e =, && e ||, e pede a leitura de uma linha do cron.

Distribuições Linux

O núcleo Linux sozinho não serve ao usuário: falta o shell, os utilitários, o instalador, a interface gráfica e os programas. Uma distribuição Linux (distro) é o pacote completo que junta o núcleo Linux, as ferramentas GNU, um gerenciador de pacotes, um instalador, os programas e, em geral, um ambiente gráfico. Todas usam o mesmo núcleo, e o que muda entre elas é a escolha dos programas, o formato de pacote, o ritmo de atualização e o público.

Pacotes e gerenciadores. O pacote é um arquivo que traz um programa pronto para instalar, com a lista das dependências, isto é, os outros pacotes de que ele precisa. O gerenciador de pacotes baixa os pacotes de repositórios (servidores com os programas aprovados pela distribuição), resolve as dependências, instala, atualiza e remove. Há duas camadas: a ferramenta de baixo nível instala um arquivo de pacote local e não baixa dependências; a ferramenta de alto nível usa os repositórios e resolve as dependências.

Família Debian. O Debian é uma distribuição mantida por uma comunidade de voluntários, conhecida pela estabilidade. Os pacotes têm a extensão .deb, a ferramenta de baixo nível é o dpkg e a de alto nível é o apt (com o apt-get, mais antigo). Da família Debian vêm o Ubuntu, mantido pela empresa Canonical, o Linux Mint, baseado no Ubuntu, e o Kali Linux, voltado a testes de segurança.

O Ubuntu lança versões de suporte de longo prazo (LTS, Long Term Support) a cada dois anos, com cinco anos de suporte padrão, e versões intermediárias com suporte curto. Os órgãos públicos usam a versão LTS nos servidores, porque ela recebe correções por mais tempo.

Família Red Hat. O Red Hat Enterprise Linux (RHEL) é a distribuição comercial da empresa Red Hat, vendida por assinatura com suporte. Os pacotes têm a extensão .rpm, a ferramenta de baixo nível é o rpm e a de alto nível é o dnf, que substituiu o yum. O Fedora é a distribuição comunitária patrocinada pela Red Hat, onde as novidades aparecem antes de chegar ao RHEL.

O CentOS Linux era uma recompilação gratuita do RHEL e foi descontinuado; deu lugar ao CentOS Stream, que fica um passo à frente do RHEL. O Rocky Linux e o AlmaLinux assumiram o papel de alternativas gratuitas compatíveis com o RHEL, e o Oracle Linux também segue o RHEL. A família SUSE (openSUSE e SUSE Linux Enterprise) também usa pacotes .rpm, mas com o gerenciador zypper e a ferramenta de configuração YaST.

Outras distribuições. O Arch Linux é minimalista: o usuário monta o sistema peça por peça, e o gerenciador é o pacman. O Gentoo compila os programas a partir do código-fonte, com o sistema Portage (comando emerge), para ajustar cada programa à máquina. O Slackware é uma das distribuições mais antigas ainda mantidas e segue um modelo simples, perto do Unix tradicional. O Alpine Linux é muito pequeno, usa o gerenciador apk e é comum em contêineres.

Exemplo resolvido: instalar o servidor web nginx e atualizar o sistema num servidor Ubuntu e num servidor Rocky Linux.

1. Ubuntu (família Debian): sudo apt update atualiza a lista de pacotes dos repositórios.
2. Ubuntu: sudo apt install nginx baixa e instala o nginx com as dependências.
3. Ubuntu: sudo apt upgrade instala as versões novas dos pacotes já instalados.
4. Rocky Linux (família Red Hat): sudo dnf install nginx instala o nginx com as dependências; o dnf já consulta os repositórios na hora.
5. Rocky Linux: sudo dnf upgrade atualiza os pacotes instalados.
6. Para um arquivo baixado à parte, o Ubuntu usa sudo dpkg -i pacote.deb e o Rocky usa sudo rpm -ivh pacote.rpm; nenhum dos dois resolve as dependências sozinho.

No Debian e no Ubuntu, o apt update só renova a lista e não instala nada; quem instala as versões novas é o apt upgrade. Essa troca é frequente.

Modelos de lançamento. No lançamento fixo (fixed release), a distribuição publica versões numeradas, congela os programas de cada versão e só manda correções até a versão seguinte: Debian, Ubuntu, RHEL e Rocky seguem esse modelo. No lançamento contínuo (rolling release), não há versão nova: o sistema recebe as atualizações sem parar, e a instalação está sempre na última versão de cada programa. O Arch Linux e o openSUSE Tumbleweed seguem o modelo contínuo.

O lançamento fixo dá estabilidade, e por isso domina nos servidores. O lançamento contínuo traz as novidades primeiro, com mais risco de uma atualização quebrar algo.

Ambientes gráficos. A interface gráfica não faz parte do núcleo. O servidor gráfico (o X11, chamado de X Window System, ou o Wayland, mais novo) desenha as janelas, e o ambiente de área de trabalho dá a cara do sistema: GNOME (padrão do Ubuntu e do Fedora), KDE Plasma, Xfce e LXQt (leves, para máquinas antigas), Cinnamon e MATE (do Linux Mint). Uma mesma distribuição aceita vários ambientes, e um servidor costuma rodar sem nenhum.

Mídia live e usos do núcleo. Muitas distribuições oferecem a mídia live: o sistema roda direto do pen drive ou do DVD, sem instalar nada no disco, o que serve para testar a distribuição ou recuperar arquivos de um computador com defeito. O núcleo Linux também está fora dos computadores de mesa: o Android usa o núcleo Linux, e a maior parte dos servidores e dos supercomputadores roda distribuições Linux.

Na prática, a equipe de TI de um tribunal escolhe o sistema para os servidores de banco de dados e quer suporte pago do fabricante. A escolha natural é o RHEL, com contrato de suporte. Se o tribunal não quer pagar a assinatura e quer compatibilidade com o RHEL, ele usa o Rocky Linux ou o AlmaLinux, com os mesmos comandos dnf e rpm.

A diferença para o conceito vizinho: o núcleo é o mesmo em todas as distribuições, e o que separa as famílias é o formato de pacote e o gerenciador (.deb com dpkg e apt; .rpm com rpm e dnf). O erro comum é ligar o Ubuntu à família Red Hat ou achar que o Fedora é a versão paga do RHEL.

Como a banca cobra: a banca pede a família de cada distribuição, o formato de pacote e o gerenciador de cada família, a diferença entre apt update e apt upgrade, e o modelo de lançamento do Arch e do Debian.

Quadros e comparações

A tabela compara as famílias de distribuições pelo pacote e pelos gerenciadores.

A tabela compara o link físico e o link simbólico.

A tabela compara as permissões especiais.

A tabela compara comandos que a prova troca.

Para decorar

Pegadinhas

Fontes e data

• [1] POSIX.1 (IEEE Std 1003.1), edição de 2024, interface padrão dos sistemas do tipo Unix.
• [2] FHS 3.0 (Filesystem Hierarchy Standard), da Linux Foundation.
• [3] Conhecimento consolidado de livro didático de sistemas operacionais (Unix, Linux, shell e distribuições).

Texto conferido em 15/10/2026.