curso online
Linux Essentials & Security

Linux Essentials & Security

Curso voltado para alunos de Engenharia de Redes: fundamentos do SO, administração, diagnóstico de redes e segurança defensiva em ambientes reais com Linux.

01
Fundamentos

Kernel, shell, FHS, navegação e documentação.

02
Administração

Usuários, permissões, processos, pacotes e logs.

03
Redes

Interfaces, DNS, rotas, portas e diagnóstico TCP/IP.

04
Segurança

Hardening, SSH, firewall, auditoria e fail2ban.

Critério pedagógico: nenhum comando aparece sem finalidade. O aluno deve saber o que está observando, por que aquele comando existe e qual risco está sendo gerenciado.

Painel

Dashboard do aluno

Progresso por módulo

Módulo 1 — Fundamentos

Módulo 2 — Administração

Módulo 3 — Redes

Módulo 4 — Segurança

Sessão do aluno

Autentique com sua conta GitHub para manter o progresso vinculado ao seu perfil. O progresso é salvo localmente neste dispositivo.

Mapa

Organização acadêmica do curso

1. Teoriaconceito, contexto e risco
2. Diagramavisualização da arquitetura
3. Comandofinalidade e sintaxe
4. Saídao que observar
5. Práticaexecução em laboratório
6. Avaliaçãoquestões objetivas
Módulo 1

Fundamentos Linux

Do Unix ao shell: visão histórica e conceitual, terminal, árvore de diretórios, documentação e comandos essenciais — tudo conectado à prática de redes.

M1-A1

Aula 1.1 — Unix, GNU/Linux e distribuições

Objetivo: Compreender a origem do Linux, o papel das distribuições e por que servidores, redes e segurança usam amplamente ambientes Unix-like.

Teoria essencial

  • Unix (1969, Bell Labs): sistema multitarefa e multiusuário que introduziu a filosofia de ferramentas pequenas, combinadas por texto. Cada programa faz uma coisa bem; a composição cria poder.
  • GNU (1983, Richard Stallman): projeto para criar um sistema operacional livre compatível com Unix. Produziu compiladores (GCC), editores (Emacs), shell (bash) e centenas de utilitários — mas não o kernel.
  • Linux (1991, Linus Torvalds): o kernel que completou o sistema GNU. A combinação GNU/Linux forma o que popularmente chamamos de "Linux".
  • Distribuição: integração de kernel + shell + bibliotecas + gerenciador de pacotes + documentação + comunidade. Exemplos: Debian, Ubuntu, RHEL, Fedora, Arch.
  • Relevância para redes: mais de 70 % dos servidores, 90 % da infraestrutura em nuvem, roteadores comerciais (Cisco IOS-XE, Junos) e switches correm Linux ou derivados Unix.
Conceito-chave: filosofia Unix "Escreva programas que façam uma coisa e façam bem. Escreva programas que trabalhem juntos. Escreva programas que tratem texto como interface universal." — Doug McIlroy, 1978. Essa filosofia é o motivo pelo qual grep | awk | sort | uniq é mais poderoso que qualquer ferramenta monolítica.

Famílias de distribuições Linux

FamíliaDistribuiçõesGerenciadorUso típico em redes
DebianDebian, Ubuntu, Kali Linux, Raspberry Pi OSapt / dpkgLaboratórios, servidores web, pentest (Kali)
Red HatRHEL, Rocky Linux, AlmaLinux, Fedora, CentOSdnf / rpmServidores corporativos, ambientes certificados
SUSEopenSUSE Leap, SLESzypper / rpmTelecomunicações, mainframe
ArchArch Linux, ManjaropacmanUso avançado, customização total
Dica para engenheiros de redes Em laboratórios acadêmicos, prefira Ubuntu Server LTS (suporte de 5 anos). Em ambientes corporativos, RHEL/Rocky Linux são os mais exigidos no mercado. Em testes de segurança, Kali Linux já traz ferramentas instaladas.

Comandos explicados

$ uname -a          # Kernel, hostname, arquitetura e data de compilação
$ cat /etc/os-release # Nome e versão da distribuição
$ hostnamectl       # Hostname, distro, kernel e tipo de virtualização
$ lsb_release -a   # Resumo da distro (requer lsb-release instalado)
$ whoami            # Usuário efetivo da sessão
Linux debian 6.1.0-21-amd64 #1 SMP PREEMPT_DYNAMIC Debian 6.1.90-1 x86_64 GNU/Linux
PRETTY_NAME="Debian GNU/Linux 12 (bookworm)"
NAME="Debian GNU/Linux"
VERSION_ID="12"
ID=debian
   Static hostname: srv-redes
         Icon name: computer-vm
           Chassis: vm
        Machine ID: a3f2...
           Boot ID: c91e...
  Operating System: Debian GNU/Linux 12 (bookworm)
            Kernel: Linux 6.1.0-21-amd64
      Architecture: x86-64
   Virtualization: kvm

Atividade prática exigida

  1. Identifique distribuição, versão, kernel e arquitetura.
  2. Descubra a família da distribuição e qual gerenciador de pacotes ela usa.
  3. Explique a diferença entre "Linux como kernel" e "Linux como distribuição".
  4. Pesquise qual distro é mais utilizada em servidores de ISP na sua região.

Entrega: relatório Markdown — comando, saída, interpretação e conclusão.

M1-A2

Aula 1.2 — Kernel, shell e chamadas de sistema

Objetivo: Entender que comandos não falam diretamente com o hardware: o shell interpreta, programas executam syscalls e o kernel gerencia todos os recursos.

Teoria essencial

  • Kernel: núcleo do SO. Controla processos, memória, sistema de arquivos, dispositivos e rede. Roda em modo privilegiado (Ring 0 na arquitetura x86), com acesso irrestrito ao hardware.
  • User Space: onde rodam aplicações, shell e bibliotecas. Operam em Ring 3 — sem acesso direto ao hardware. Para acessar recursos do kernel, precisam fazer syscalls.
  • Syscall (chamada de sistema): mecanismo de solicitação controlada ao kernel. Ex: open() para abrir arquivo, socket() para criar socket de rede, send()/recv() para transmitir dados.
  • Shell: interpretador de comandos que recebe texto do usuário, faz expansões (variáveis, globs, subshells), e cria processos (fork + exec) para cada comando.
  • Importância para segurança: a separação kernel/user impede que processos comuns acessem memória de outros processos ou hardware diretamente — base do isolamento de segurança.

Diagrama: Arquitetura de camadas do Linux

HARDWARE CPU RAM DISCO PLACA DE REDE USB/PCI KERNEL SPACE — Ring 0 Scheduler Processos/CPU Memória Paginação/Swap Stack TCP/IP Sockets/Filtros VFS ext4/xfs/tmpfs LSM SELinux/AppArmor Drivers de Dispositivo placa de rede · controladora de disco · USB · áudio · framebuffer · serial… ── INTERFACE DE SYSCALLS ── USER SPACE — Ring 3 Aplicações curl ssh vim ping ps nmap… Shell bash · zsh · fish · dash Bibliotecas de Sistema glibc · musl · libpthread · OpenSSL…
Fig. 1 — Arquitetura de camadas do Linux. O kernel media todo acesso ao hardware; aplicações nunca acessam hardware diretamente.

Chamadas de sistema relevantes para redes

SyscallO que fazExemplo de uso
socket()Cria um socket de redeQualquer aplicação cliente/servidor
bind()Associa socket a endereço/portaServidor HTTP ouvindo na porta 80
connect()Inicia conexão TCPcurl abrindo conexão HTTPS
send()/recv()Envia/recebe dadosTransferência de dados em qualquer protocolo
open()Abre arquivo (retorna file descriptor)cat, ls lendo /proc/net/tcp
fork()/exec()Cria processo filho / substitui imagemShell criando cada comando
Atenção — segurança A separação entre kernel space e user space é a principal barreira de segurança do SO. Vulnerabilidades de privilege escalation geralmente exploram falhas que permitem que código de user space execute com privilégios de Ring 0. Por isso, manter o kernel atualizado é obrigação, não opção.

Comandos explicados

$ echo $SHELL                          # Shell padrão configurado na conta
$ ps -p $$                           # Processo do shell atual (PID e nome)
$ strace -c ls >/dev/null 2>&1       # Resume syscalls feitas por ls
$ strace -e trace=network curl -s http://1.1.1.1 >/dev/null # Syscalls de rede do curl
$ dmesg | tail -20                  # Mensagens recentes do kernel
$ cat /proc/version                  # Versão do kernel e compilador usado
/bin/bash
  PID TTY          TIME CMD
 1234 pts/0    00:00:00 bash

% time     seconds  usecs/call     calls    errors syscall
------ ----------- ----------- --------- --------- ----------------
 28.45    0.000112          11        10           read
 24.88    0.000098           8        12         2 openat
 18.52    0.000073           6        12           mmap
 ...
socket(AF_INET, SOCK_STREAM, IPPROTO_TCP) = 3
connect(3, {sa_family=AF_INET, sin_port=htons(80), sin_addr=...}, 16)

Atividade prática exigida

  1. Desenhe o fluxo completo: Usuário → Shell → Programa → Syscall → Kernel → Hardware.
  2. Use strace -e trace=network em um comando de rede e identifique a syscall connect().
  3. Compare a saída de echo $SHELL e ps -p $$ — eles sempre batem? Por quê?
  4. Explique por que dmesg pode exigir privilégios em sistemas modernos.

Entrega: relatório Markdown — comando, saída, interpretação e conclusão.

M1-A3

Aula 1.3 — Hierarquia de diretórios Linux (FHS)

Objetivo: Localizar configurações, logs, usuários, binários, dispositivos e arquivos virtuais do kernel com segurança e precisão.

Teoria essencial

  • FHS — Filesystem Hierarchy Standard: padrão que define onde cada tipo de arquivo deve residir. Garante previsibilidade entre distros.
  • Raiz única (/): Linux usa uma árvore única. Discos, partições e dispositivos de rede são montados como subdiretórios — não existem letras de unidade como no Windows.
  • Inode: estrutura interna que armazena metadados (permissões, dono, timestamps, tamanho, ponteiros para blocos). O nome do arquivo é apenas uma entrada de diretório que aponta para o inode.
  • Sistemas de arquivos virtuais: /proc e /sys não existem em disco — são gerados pelo kernel em tempo real, expondo estado interno. /dev é gerenciado pelo udev.
  • Implicação para redes: configurações de interfaces de rede ficam em /etc/network/ ou /etc/netplan/; logs em /var/log/; dispositivos de rede em /sys/class/net/.

Mapa visual da hierarquia

/ /bin Binários essenciais /boot Kernel e bootloader /dev Dispositivos (virtual) /etc Configs do sistema /home Diretórios usuários /proc Processos (virtual) /sys Hardware (virtual) /usr Programas e libs /var Logs e dados var. /tmp Temporários limpos boot passwd shadow · group network/ netplan/ iface ssh/ sshd_config hosts resolv.conf fstab crontab · sysctl log/ syslog · auth.log cache/ apt/ pip/ spool/ mail · cron Legenda: Configs/logs (mais usados em administração) Sistema de arquivos virtual (kernel) Binários / dados de sistema Arquivos virtuais em /proc e /sys não estão em disco — são gerados pelo kernel em tempo real e refletem o estado atual do sistema.
Fig. 2 — Hierarquia FHS com subdiretórios de /etc e /var mais relevantes para administração de redes.

Comandos explicados

$ ls -lah /                          # Lista raiz com tamanhos legíveis
$ find /etc -maxdepth 1 -type f | head # Arquivos diretos em /etc
$ cat /proc/net/if_inet6              # Interfaces IPv6 via sysfs virtual
$ ls /sys/class/net                   # Interfaces de rede expostas pelo kernel
$ stat /etc/passwd                    # Inode, permissões e timestamps de arquivo
$ df -hT                               # Sistemas de arquivos montados com tipo
$ mount | grep -E "proc|sys|dev"      # Confirma que /proc e /sys são virtuais

Atividade prática exigida

  1. Monte uma tabela com 12 diretórios, suas funções e um arquivo de exemplo em cada um.
  2. Identifique três arquivos em /etc relacionados a redes e explique cada um.
  3. Compare /proc e /sys: qual expõe processos? Qual expõe hardware?
  4. Execute stat em dois arquivos e explique cada campo do inode exibido.

Entrega: relatório Markdown com comando, saída, interpretação e conclusão.

M1-A4

Aula 1.4 — Navegação, arquivos, pipes e redirecionamento

Objetivo: Usar o terminal com autonomia — pipes, redirecionamentos, manipulação de arquivos e documentação interna — sem depender de memorização mecânica.

Teoria essencial

  • Caminho absoluto vs relativo: caminho absoluto começa em / e identifica o arquivo de forma única independentemente do diretório atual. Relativo parte do diretório corrente (pwd).
  • Redirecionamento: operadores que controlam fluxo de stdin (0), stdout (1) e stderr (2). Fundamentais para automação e scripts de rede.
  • Pipe (|): encadeia comandos: stdout de um é stdin do próximo. Permite filtrar, ordenar e analisar saídas de comandos sem criar arquivos intermediários.
  • Documentação interna: man, info, --help, apropos e whatis devem ser a primeira fonte de consulta — não a Internet — para construir autonomia técnica.

Operadores de redirecionamento

OperadorSignificadoExemplo
>Redireciona stdout — cria/sobrescreve arquivoip addr show > interfaces.txt
>>Redireciona stdout — acrescenta ao arquivodate >> audit.log
2>Redireciona stderrfind / -name x 2>/dev/null
2>&1Redireciona stderr para stdoutcomando > saida.txt 2>&1
<Redireciona stdin de arquivosort < lista.txt
|Pipe: stdout → stdin do próximoss -tulpen | grep 22
Combinações poderosas para redes ss -tulpen | grep LISTEN | awk '{print $5, $7}' — filtra portas em escuta e mostra endereço e processo.
cat /var/log/auth.log | grep "Failed" | awk '{print $11}' | sort | uniq -c | sort -rn | head — top IPs com falha de autenticação.

Comandos explicados

$ pwd                                 # Diretório corrente (Print Working Directory)
$ ls -lah --color=auto              # Lista com tamanho, ocultos, cor
$ cd /var/log && ls               # Muda para /var/log e lista se sucesso
$ mkdir -p lab/{conf,logs,scripts}  # Cria estrutura de diretórios de uma vez
$ cp /etc/hosts lab/conf/           # Copia arquivo preservando nome
$ grep -n "nameserver" /etc/resolv.conf # Busca com número de linha
$ wc -l /var/log/syslog              # Conta linhas do log
$ tail -f /var/log/syslog            # Monitora log em tempo real (Ctrl+C para sair)
$ man ip                              # Manual completo do comando ip
$ apropos "network interface"          # Busca páginas de manual por palavra-chave
Cuidado — operações destrutivas rm -rf /caminho/errado não tem confirmação e não tem lixeira. Em servidores, rm, mv e redirecionamento com > podem apagar dados irrecuperáveis. Sempre confira o caminho antes de executar.

Atividade prática exigida

  1. Crie a estrutura ~/lab/{conf,logs,scripts} e coloque um arquivo de exemplo em cada pasta.
  2. Use um pipe com grep, sort e uniq -c para analisar /var/log/auth.log.
  3. Use man ls para descobrir a opção que ordena por data de modificação.
  4. Explique a diferença entre 2>/dev/null e >/dev/null 2>&1.

Entrega: relatório Markdown com comando, saída, interpretação e conclusão.

Avaliação do módulo — Fundamentos Linux

10 questões objetivas. Aprovação: 70 % (7/10).

Módulo 2

Administração Linux

Usuários, grupos, permissões, processos, serviços, pacotes, logs e automação com cron — controle total do ambiente Linux.

M2-A1

Aula 2.1 — Usuários, grupos e identidade

Objetivo: Entender como o Linux representa identidades e como UID/GID afetam acesso a arquivos, processos e serviços.

Teoria essencial

  • UID (User ID): número inteiro que identifica unicamente um usuário no kernel. O kernel trabalha apenas com UIDs; nomes são resolvidos por bibliotecas. UID 0 = root.
  • GID (Group ID): análogo ao UID para grupos. Um usuário tem um GID primário e pode pertencer a vários grupos suplementares.
  • Contas de serviço (UIDs 1–999): criadas para daemons (www-data, sshd, nobody). Não têm shell interativo (/usr/sbin/nologin) e não devem ter senha válida.
  • Contas de usuários (UIDs ≥ 1000): contas humanas com diretório home e shell válido.
  • Princípio do menor privilégio: cada processo, serviço e usuário deve ter apenas as permissões mínimas necessárias para sua função.

Estrutura dos arquivos de identidade

/etc/passwd — Contas de usuário (legível por todos) ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ usuario : x : UID : GID : GECOS : home : shell │ │ │ │ │ │ │ │ │ │ │ │ │ └─ /bin/bash ou /sbin/nologin │ │ │ │ │ └─ /home/usuario │ │ │ │ └─ descrição (nome completo, sala...) │ │ │ └─ GID primário │ │ └─ UID numérico │ └─ 'x' → senha está em /etc/shadow └─ nome de login /etc/shadow — Hashes de senha (apenas root) ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ usuario : $6$salt$hash : last : min : max : warn : inactive : expire : : └─ $6$ = SHA-512 (recomendado) /etc/group — Grupos ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ grupo : x : GID : membro1,membro2
Atenção — /etc/shadow /etc/shadow deve ter permissão 640 ou 000, legível apenas por root (ou grupo shadow). Contém hashes de senha — exposição permite ataque offline de dicionário. Verifique: ls -l /etc/shadow deve mostrar -rw-r----- ou ----------.

Comandos explicados

$ id                                  # UID, GID primário e todos os grupos
$ id www-data                         # Identidade de conta de serviço
$ getent passwd $USER                # Linha de /etc/passwd do usuário atual
$ getent group sudo                   # Membros do grupo sudo
$ groups                              # Grupos do usuário atual
$ sudo -l                             # Permissões sudo disponíveis para o usuário
$ sudo useradd -m -s /bin/bash aluno2 # Cria usuário com home e shell
$ sudo usermod -aG sudo aluno2       # Adiciona ao grupo sudo (Debian/Ubuntu)
$ sudo passwd -l aluno2              # Bloqueia conta sem remover
uid=1000(aluno) gid=1000(aluno) groups=1000(aluno),4(adm),24(cdrom),27(sudo),30(dip)

aluno:x:1000:1000:Aluno de Redes,,,:/home/aluno:/bin/bash

uid=33(www-data) gid=33(www-data) groups=33(www-data)

Atividade prática exigida

  1. Liste UID, GID e grupos suplementares de sua conta. Identifique grupos privilegiados.
  2. Identifique 3 contas de serviço em /etc/passwd e explique o que cada daemon faz.
  3. Crie uma conta de laboratório, defina senha e verifique o hash gerado em /etc/shadow.
  4. Explique por que pertencer ao grupo sudo ou wheel é equivalente a ter acesso root.

Entrega: relatório Markdown com comando, saída, interpretação e conclusão.

M2-A2

Aula 2.2 — Permissões em arquivos e diretórios

Objetivo: Dominar rwx, notação octal, bits especiais e entender como permissões se comportam de forma diferente em arquivos e diretórios.

Teoria essencial

  • Modelo DAC (Discretionary Access Control): o dono do arquivo controla quem pode acessá-lo. O kernel avalia: dono → grupo → outros (em ordem, parando na primeira correspondência).
  • Em arquivo: r = ler conteúdo, w = modificar conteúdo, x = executar como programa.
  • Em diretório: r = listar nomes dos arquivos, w = criar/remover entradas (mais crítico que em arquivo!), x = traversar o caminho.
  • SUID (4): executável roda com UID do dono em vez do usuário chamador. Ex: passwd precisa de SUID para escrever em /etc/shadow.
  • SGID (2): em diretório, novos arquivos herdam o grupo do diretório — útil para colaboração.
  • Sticky bit (1): em diretório, só o dono pode remover seus próprios arquivos. Ex: /tmp.

Tabela de permissões octais

OctalBinárioPermissãoExemplo de uso
7111rwxDono de diretório de projeto
6110rw-Arquivo de configuração do dono
5101r-xScript executável para grupo
4100r--Arquivo público somente leitura
3011-wxRaro; diretório de escrita sem listagem
2010-w-Raro em prática
1001--xTraversar diretório sem listar
0000---Sem acesso
Conceito-chave: chmod 750 chmod 750 projeto → dono: rwx (7) | grupo: r-x (5) | outros: --- (0)
Intepretação: o dono pode tudo; o grupo pode ler e entrar; usuários fora do grupo não veem nada. Uso comum: diretório de projeto compartilhado dentro de uma equipe.

Comandos explicados

$ ls -l /etc/passwd /etc/shadow       # Compara permissões dos dois arquivos
$ chmod 750 projeto                    # Define rwxr-x---
$ chmod -R 640 projeto/conf/           # Aplica recursivamente
$ chown aluno:turma projeto            # Altera dono e grupo
$ chmod g+s projeto/                   # SGID: novos arquivos herdam grupo
$ chmod +t /tmp/compartilhado        # Sticky bit: só dono remove seus arquivos
$ umask                                # Máscara padrão (022 → arquivos 644, dirs 755)
$ find / -perm -4000 -type f 2>/dev/null | head # Binários SUID no sistema
-rw-r--r-- 1 root root   2890 Jan 10 08:00 /etc/passwd
-rw-r----- 1 root shadow 1520 Jan 10 08:00 /etc/shadow

/usr/bin/passwd
/usr/bin/sudo
/usr/bin/su
/usr/bin/newgrp
/usr/bin/mount
Risco — binários SUID Cada binário SUID mal configurado é um vetor de escalonamento de privilégios. Um invasor com shell limitado pode usar um binário SUID vulnerável para obter root. Mantenha a lista de binários SUID mínima e auditada regularmente.

Atividade prática exigida

  1. Crie empresa/{financeiro,rh,ti} com grupos e permissões coerentes para cada setor.
  2. Aplique SGID ao diretório compartilhado e valide que novos arquivos herdam o grupo.
  3. Explique em que cenário o sticky bit em /tmp previne problemas entre usuários.
  4. Liste binários SUID e justifique quais são necessários e quais deveriam ser auditados.

Entrega: relatório Markdown com comando, saída, interpretação e conclusão.

M2-A3

Aula 2.3 — Processos e serviços

Objetivo: Analisar processos, estados, sinais e serviços persistentes gerenciados pelo systemd.

Teoria essencial

  • Processo: instância em execução de um programa. Cada processo tem PID único, PPID (pai), UID/GID (segurança) e descritores de arquivo abertos.
  • systemd (PID 1): init system moderno que gerencia todos os processos de usuário. Substituiu SysV init. Mantém unidades (units): .service, .socket, .timer, .mount, .target.
  • cgroups (Control Groups): mecanismo do kernel para agrupar processos e limitar uso de CPU, memória, I/O de disco e de rede por grupo. systemd usa cgroups internamente.
  • journald: daemon que coleta logs de todos os serviços, kernel e sistema de forma estruturada, com suporte a filtros poderosos.

Estados de processo no Linux

CRIADO fork() PRONTO aguarda CPU RODANDO na CPU (R) DORMINDO interruptível S ESPERANDO ininterrupt. D PARADO SIGSTOP (T) ZUMBI sem wait() Z
Fig. 3 — Estados de processo no Linux. Processos no estado D (uninterruptible sleep) geralmente aguardam I/O de disco ou rede — importante para diagnóstico de travamentos.

Sinais Unix importantes

SinalNúmeroComportamento padrãoUso típico
SIGHUP1Encerrar (ou recarregar config em daemons)kill -HUP para recarregar nginx/sshd sem parar
SIGINT2Interromper processoCtrl+C no terminal
SIGTERM15Encerrar controladamente (pode ser capturado)Padrão de kill PID — processo pode limpar
SIGKILL9Encerrar imediatamente (não pode ser ignorado)Último recurso — processo não pode limpar estado
SIGSTOP19Pausar processo (não pode ser ignorado)Suspender processo temporariamente
SIGCONT18Continuar processo paradoRetomar processo suspenso por SIGSTOP

Comandos explicados

$ ps aux | head -15                 # Lista processos com usuário, CPU e memória
$ ps -eo pid,ppid,user,stat,cmd | head # Formato customizado
$ pgrep -a sshd                      # PID(s) do processo sshd
$ systemctl status ssh               # Estado do serviço SSH
$ systemctl --type=service --state=running # Todos os serviços ativos
$ journalctl -u ssh --since today    # Logs do serviço SSH de hoje
$ kill -TERM 1234                    # Encerramento controlado (PID 1234)
$ kill -9 1234                       # Encerramento forçado — só se -TERM falhar
$ systemctl list-units --failed      # Serviços com falha

Atividade prática exigida

  1. Liste todos os processos em estado D (uninterruptible sleep) e explique o que pode causá-los.
  2. Escolha um serviço instalado, verifique status, logs e dependências com systemctl show.
  3. Explique por que usar kill -9 indiscriminadamente é ruim em servidores de banco de dados.
  4. Identifique o serviço de rede ativo (ssh, nginx, etc.) e verifique se ele reinicia automaticamente (Restart= na unit).

Entrega: relatório Markdown com comando, saída, interpretação e conclusão.

M2-A4

Aula 2.4 — Pacotes, logs e automação com cron

Objetivo: Administrar instalação, atualização e diagnóstico de pacotes, interpretar logs e automatizar tarefas periódicas sem quebrar o sistema.

Teoria essencial

  • Gerenciador de pacotes: resolve dependências, verifica integridade (assinatura GPG) e mantém banco de dados local do que está instalado. apt (Debian/Ubuntu) e dnf/yum (RHEL/Fedora) são os principais.
  • Ciclo de atualização: em servidores de produção, atualizações devem ter janela de manutenção, testes em staging e plano de rollback — não só apt upgrade -y.
  • logrotate: rotaciona, comprime e expira arquivos de log automaticamente, prevenindo que /var/log encha o disco.
  • cron: agendador de tarefas. Sintaxe de 5 campos: minuto hora dia-do-mês mês dia-da-semana. systemd timers é a alternativa moderna.

Comparação apt vs dnf

Operaçãoapt (Debian/Ubuntu)dnf (RHEL/Fedora)
Atualizar índiceapt updatednf check-update
Instalar pacoteapt install NOMEdnf install NOME
Remover pacoteapt remove NOMEdnf remove NOME
Atualizar sistemaapt upgradednf upgrade
Buscar pacoteapt search NOMEdnf search NOME
Info do pacoteapt show NOMEdnf info NOME
Listar instaladosdpkg -lrpm -qa
Qual pacote tem arquivodpkg -S /caminhorpm -qf /caminho

Sintaxe do crontab

┌──── minuto (0–59) │ ┌─── hora (0–23) │ │ ┌── dia do mês (1–31) │ │ │ ┌─ mês (1–12) │ │ │ │ ┌ dia da semana (0–7, 0=Dom) │ │ │ │ │ * * * * * /comando/a/executar Exemplos: 0 2 * * * /usr/bin/rsync -av /dados /backup # todos os dias 02:00 */5 * * * * /usr/local/bin/check_iface.sh # a cada 5 minutos 0 0 1 * * /usr/bin/apt update && apt upgrade -y # 1º dia do mês 00:00

Comandos explicados

$ sudo apt update && apt list --upgradable # Atualiza índice e lista o que pode ser atualizado
$ dpkg --verify                        # Verifica integridade dos pacotes instalados
$ journalctl -p warning --since today  # Avisos e erros desde hoje
$ journalctl -u ssh -n 50 --no-pager  # Últimas 50 linhas do log SSH
$ du -sh /var/log/* | sort -rh | head # Maiores arquivos de log
$ crontab -l                           # Lista crontab do usuário atual
$ crontab -e                           # Edita crontab do usuário atual
$ cat /etc/cron.d/*                    # Crontabs de sistema e de pacotes
Atenção — atualização em produção Nunca execute apt upgrade diretamente em servidor de produção sem: (1) testar antes em staging, (2) fazer backup/snapshot, (3) ler o changelog dos pacotes críticos (kernel, bibliotecas SSL, banco de dados), (4) ter plano de rollback definido.

Atividade prática exigida

  1. Liste pacotes atualizáveis e identifique quais são críticos (kernel, openssl, openssh).
  2. Crie um crontab que faça backup de /etc toda noite às 03:00 para /backup/etc-AAAA-MM-DD/.
  3. Identifique os 5 maiores arquivos de log e proponha política de logrotate para eles.
  4. Explique os riscos de atualizar OpenSSL em um servidor SSH ativo.

Entrega: relatório Markdown com comando, saída, interpretação e conclusão.

Avaliação do módulo — Administração Linux

10 questões objetivas. Aprovação: 70 % (7/10).