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.
Sign in with GitHub
Digite seu username do GitHub para vincular sua sessão. O nome de usuário é verificado pela API pública do GitHub.
Apenas o username é usado. Nenhuma senha ou token é solicitado.
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.
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".
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ília
Distribuições
Gerenciador
Uso típico em redes
Debian
Debian, Ubuntu, Kali Linux, Raspberry Pi OS
apt / dpkg
Laboratórios, servidores web, pentest (Kali)
Red Hat
RHEL, Rocky Linux, AlmaLinux, Fedora, CentOS
dnf / rpm
Servidores corporativos, ambientes certificados
SUSE
openSUSE Leap, SLES
zypper / rpm
Telecomunicações, mainframe
Arch
Arch Linux, Manjaro
pacman
Uso 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
Identifique distribuição, versão, kernel e arquitetura.
Descubra a família da distribuição e qual gerenciador de pacotes ela usa.
Explique a diferença entre "Linux como kernel" e "Linux como distribuição".
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
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
Syscall
O que faz
Exemplo de uso
socket()
Cria um socket de rede
Qualquer aplicação cliente/servidor
bind()
Associa socket a endereço/porta
Servidor HTTP ouvindo na porta 80
connect()
Inicia conexão TCP
curl abrindo conexão HTTPS
send()/recv()
Envia/recebe dados
Transferência de dados em qualquer protocolo
open()
Abre arquivo (retorna file descriptor)
cat, ls lendo /proc/net/tcp
fork()/exec()
Cria processo filho / substitui imagem
Shell 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-cls>/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
Desenhe o fluxo completo: Usuário → Shell → Programa → Syscall → Kernel → Hardware.
Use strace -e trace=network em um comando de rede e identifique a syscall connect().
Compare a saída de echo $SHELL e ps -p $$ — eles sempre batem? Por quê?
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
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
Monte uma tabela com 12 diretórios, suas funções e um arquivo de exemplo em cada um.
Identifique três arquivos em /etc relacionados a redes e explique cada um.
Compare /proc e /sys: qual expõe processos? Qual expõe hardware?
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
Operador
Significado
Exemplo
>
Redireciona stdout — cria/sobrescreve arquivo
ip addr show > interfaces.txt
>>
Redireciona stdout — acrescenta ao arquivo
date >> audit.log
2>
Redireciona stderr
find / -name x 2>/dev/null
2>&1
Redireciona stderr para stdout
comando > saida.txt 2>&1
<
Redireciona stdin de arquivo
sort < lista.txt
|
Pipe: stdout → stdin do próximo
ss -tulpen | grep 22
Combinações poderosas para redesss -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)$manip# Manual completo do comando ip$apropos "network interface" # Busca páginas de manual por palavra-chave
Cuidado — operações destrutivasrm -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
Crie a estrutura ~/lab/{conf,logs,scripts} e coloque um arquivo de exemplo em cada pasta.
Use um pipe com grep, sort e uniq -c para analisar /var/log/auth.log.
Use man ls para descobrir a opção que ordena por data de modificação.
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.
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$sudouseradd-m-s /bin/bash aluno2 # Cria usuário com home e shell$sudousermod-aG sudo aluno2 # Adiciona ao grupo sudo (Debian/Ubuntu)$sudopasswd-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
Liste UID, GID e grupos suplementares de sua conta. Identifique grupos privilegiados.
Identifique 3 contas de serviço em /etc/passwd e explique o que cada daemon faz.
Crie uma conta de laboratório, defina senha e verifique o hash gerado em /etc/shadow.
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
Octal
Binário
Permissão
Exemplo de uso
7
111
rwx
Dono de diretório de projeto
6
110
rw-
Arquivo de configuração do dono
5
101
r-x
Script executável para grupo
4
100
r--
Arquivo público somente leitura
3
011
-wx
Raro; diretório de escrita sem listagem
2
010
-w-
Raro em prática
1
001
--x
Traversar diretório sem listar
0
000
---
Sem acesso
Conceito-chave: chmod 750chmod 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
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
Crie empresa/{financeiro,rh,ti} com grupos e permissões coerentes para cada setor.
Aplique SGID ao diretório compartilhado e valide que novos arquivos herdam o grupo.
Explique em que cenário o sticky bit em /tmp previne problemas entre usuários.
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
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
Sinal
Número
Comportamento padrão
Uso típico
SIGHUP
1
Encerrar (ou recarregar config em daemons)
kill -HUP para recarregar nginx/sshd sem parar
SIGINT
2
Interromper processo
Ctrl+C no terminal
SIGTERM
15
Encerrar controladamente (pode ser capturado)
Padrão de kill PID — processo pode limpar
SIGKILL
9
Encerrar imediatamente (não pode ser ignorado)
Último recurso — processo não pode limpar estado
SIGSTOP
19
Pausar processo (não pode ser ignorado)
Suspender processo temporariamente
SIGCONT
18
Continuar processo parado
Retomar 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
Liste todos os processos em estado D (uninterruptible sleep) e explique o que pode causá-los.
Escolha um serviço instalado, verifique status, logs e dependências com systemctl show.
Explique por que usar kill -9 indiscriminadamente é ruim em servidores de banco de dados.
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ção
apt (Debian/Ubuntu)
dnf (RHEL/Fedora)
Atualizar índice
apt update
dnf check-update
Instalar pacote
apt install NOME
dnf install NOME
Remover pacote
apt remove NOME
dnf remove NOME
Atualizar sistema
apt upgrade
dnf upgrade
Buscar pacote
apt search NOME
dnf search NOME
Info do pacote
apt show NOME
dnf info NOME
Listar instalados
dpkg -l
rpm -qa
Qual pacote tem arquivo
dpkg -S /caminho
rpm -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
$sudoapt 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
Liste pacotes atualizáveis e identifique quais são críticos (kernel, openssl, openssh).
Crie um crontab que faça backup de /etc toda noite às 03:00 para /backup/etc-AAAA-MM-DD/.
Identifique os 5 maiores arquivos de log e proponha política de logrotate para eles.
Explique os riscos de atualizar OpenSSL em um servidor SSH ativo.
Entrega: relatório Markdown com comando, saída, interpretação e conclusão.