Introdução ao GNU/Linux

O GNU/Linux é um sistema operacional livre e de código aberto que combina o núcleo LinuxO kernel é o núcleo do sistema, responsável pela comunicação entre hardware e software com os utilitários e ferramentas do projeto GNU, idealizado por Richard Stallman nos anos 80.

Ao contrário de sistemas proprietários, o GNU/Linux oferece liberdade total aos usuários para executar, estudar, modificar e distribuir o software, conforme as quatro liberdades do software livre.

Entre suas principais características estão:

• Multitarefa e multiusuário
• Estável e altamente seguro
• Suporte a diversas arquiteturas de hardware
• Grande comunidade de desenvolvimento e suporte
• Ampla gama de distribuições adaptadas a diferentes necessidades

# Exibindo mensagem de boas-vindas no terminal
echo "Bem-vindo ao mundo GNU/Linux!"

Atualmente, o GNU/Linux está presente em diversos ambientes, desde servidores de grandes empresas até dispositivos móveis, roteadores, supercomputadores e sistemas embarcados.

Ao longo deste material, você conhecerá a história do GNU/Linux, suas principais distribuições, estrutura de diretórios, comandos essenciais, permissões e muito mais — com atividades práticas e interativas!

História do GNU/Linux

A história do GNU/Linux é uma junção de duas grandes iniciativas: o projeto GNU, iniciado por Richard Stallman na década de 1980, e o kernel Linux, criado por Linus Torvalds em 1991. Essa união deu origem a um sistema operacional livre, poderoso e altamente personalizável, hoje amplamente utilizado em servidores, desktops, dispositivos móveis e embarcados.

O projeto GNU tinha como objetivo criar um sistema operacional completamente livre e compatível com Unix. No entanto, o desenvolvimento do kernel do GNU atrasou. Paralelamente, Linus Torvalds desenvolvia um kernel como hobby para seu computador pessoal, baseado no MINIX. Ao ser licenciado sob a GPL (General Public License), esse kernel passou a complementar o projeto GNU, formando o GNU/Linux como o conhecemos.

Distribuições GNU/Linux

Distribuições GNU/Linux são sistemas operacionais completos que combinam o kernel Linux com um conjunto de softwares, gerenciadores de pacotes e ferramentas de configuração. Cada distribuição tem objetivos e públicos diferentes: algumas são voltadas para iniciantes, outras para ambientes corporativos ou usuários avançados.

As distribuições podem ser classificadas por suas famílias, com base no sistema de gerenciamento de pacotes e na comunidade ou empresa que a mantém.

Família Debian

Debian

Conhecida por sua estabilidade e foco em software livre. É a base de várias outras distribuições.

Ubuntu

Popular entre usuários domésticos e empresas. Conta com versões desktop, server e para IoT.

Linux Mint

Baseada no Ubuntu, com foco em usabilidade e familiaridade para quem vem do Windows.

Família Red Hat

Red Hat Enterprise Linux (RHEL)

Distribuição comercial voltada a servidores e empresas. Fornece suporte técnico e certificações.

Fedora

Voltada à inovação. Testa tecnologias que futuramente serão incorporadas ao RHEL.

CentOS

Era a versão gratuita do RHEL, agora substituída pelo CentOS Stream, uma versão rolling release.

Família Arch

Arch Linux

Distribuição minimalista e altamente personalizável. Ideal para usuários avançados.

Manjaro

Baseada no Arch, com foco em facilidade de uso e instalação amigável.

Existem ainda distribuições especializadas para finalidades específicas, como segurança da informação (ex: Kali Linux), privacidade (ex: Tails), servidores (ex: ClearOS) e educação (ex: Edubuntu). A escolha da distro ideal depende dos seus objetivos e familiaridade com o sistema.

Interfaces Gráficas (GUIs) no GNU/Linux

O GNU/Linux permite escolher entre diversas interfaces gráficas que determinam a aparência, comportamento e recursos da área de trabalho. Algumas são completas e modernas, outras são leves e eficientes, ideais para máquinas com poucos recursos.

GNOME

Moderna, limpa e voltada à produtividade. Padrão em distros como Ubuntu e Fedora.

KDE Plasma

Extremamente personalizável e com visual arrojado. Repleta de recursos avançados.

Cinnamon

Interface do Linux Mint, moderna e familiar para quem vem do Windows.

XFCE

Leve e estável. Excelente escolha para quem quer desempenho e simplicidade.

MATE

Baseada no antigo GNOME 2. Clássica, leve e estável.

LXQt

Extremamente leve, baseada em Qt. Ideal para máquinas antigas.

Budgie

Interface moderna desenvolvida pela equipe do Solus. Limpa, simples e bonita.

Deepin

Interface visualmente refinada e elegante. Experiência semelhante ao macOS.

Enlightenment

Leve, animada e com aparência futurista. Visual avançado com baixo consumo.

i3wm

Gerenciador de janelas em mosaico. Interface minimalista para usuários avançados.

Fluxbox

Levíssima e rápida. Ideal para sistemas com hardware antigo. Interface simplificada.

Openbox

Gerenciador de janelas leve e altamente configurável. Usado em ambientes minimalistas.

Blackbox

Minimalista, leve e rápido. Ótimo para sistemas embarcados ou sem recursos gráficos pesados.

IceWM

Interface leve com aparência clássica. Rápida, estável e com recursos básicos.

A escolha de uma interface gráfica depende do seu gosto, desempenho esperado e finalidade do sistema. No GNU/Linux, você pode até instalar mais de uma interface e escolher no login qual deseja usar. Liberdade é a essência!

Licenças de Software Livre

O movimento do Software Livre é sustentado por princípios éticos e legais que garantem liberdade aos usuários. Esses princípios são definidos por licenças que determinam como o software pode ser utilizado, estudado, modificado e redistribuído. A Free Software Foundation (FSF) estabeleceu quatro liberdades fundamentais:

Principais Licenças de Software Livre

Diversas licenças foram criadas para garantir essas liberdades. Algumas são mais rígidas (copyleft), exigindo que qualquer modificação mantenha os mesmos termos da licença original, enquanto outras são mais permissivas. Abaixo, as mais utilizadas:

# Debian/Ubuntu:
apt show nome-do-pacote | grep License

# Fedora:
dnf info nome-do-pacote | grep License

# Visualizando licença em projetos GitHub:
acessar o repositório e procurar por LICENSE ou COPYING

Entender as licenças de software é fundamental tanto para desenvolvedores quanto para usuários. Respeitar as condições de uso e contribuir com a comunidade fortalece o ecossistema do software livre.

Certificações Linux

As certificações Linux comprovam o conhecimento técnico em administração de sistemas, segurança, redes e automação. Elas são reconhecidas internacionalmente e valorizadas por empresas de tecnologia.

Instalação do GNU/Linux

Instalar uma distribuição GNU/Linux pode ser uma excelente forma de aprender mais sobre sistemas operacionais, ferramentas de linha de comando e liberdade digital. Você pode começar sem modificar seu sistema atual, usando uma versão ao vivo (live), ou optar por instalar em definitivo ao lado do Windows ou em uma máquina virtual.

1. Usando Live USB (sem instalar)

O modo Live permite experimentar o sistema Linux diretamente a partir de um pendrive, sem instalar nada no computador. Ideal para conhecer a interface e as ferramentas básicas.

• Baixe a imagem ISO da distribuição desejada (ex: Ubuntu ou Linux Mint).
• Use um programa como Rufus (Windows) ou `dd` (Linux) para gravar no pendrive.
• Reinicie o computador e acesse o menu de boot (geralmente F12, ESC ou DEL).
• Escolha a opção para iniciar pelo USB e selecione “Experimentar sem instalar”.

2. Instalação em Máquina Virtual

Utilizar uma máquina virtual permite que você rode o Linux dentro do Windows ou macOS, sem reiniciar ou particionar o disco.

• Instale um gerenciador de máquinas virtuais como VirtualBox ou VMware.
• Crie uma nova máquina virtual e selecione a ISO da distribuição como disco de boot.
• Configure memória (mínimo 2 GB) e disco (mínimo 20 GB).
• Siga o assistente de instalação da distribuição.

3. Dual Boot (instalar ao lado do Windows)

O dual boot permite manter o Windows e o Linux no mesmo computador, escolhendo o sistema operacional a cada inicialização.

• Faça backup dos seus arquivos importantes.
• Crie espaço livre no disco (mínimo 20 GB) usando o gerenciador de disco do Windows.
• Crie o Live USB e inicialize por ele.
• Durante a instalação, escolha a opção “Instalar ao lado do Windows”.
• Conclua a instalação e reinicie. O gerenciador de boot GRUB será exibido com as opções.

# Verifique o nome do dispositivo USB com:
lsblk

# Substitua /dev/sdX pelo nome correto do seu pendrive
sudo dd if=ubuntu.iso of=/dev/sdX bs=4M status=progress

Independentemente da forma escolhida, experimente, explore e não tenha medo de testar. O GNU/Linux é um sistema que incentiva a curiosidade e o aprendizado contínuo.

Estrutura de Diretórios no GNU/Linux

O sistema de arquivos no GNU/Linux segue o padrão FHS (Filesystem Hierarchy Standard), que organiza os arquivos em uma estrutura de diretórios hierárquica, começando pela raiz /. Cada diretório tem uma função específica no funcionamento do sistema.

ls -l /
tree -L 1 /

Compreender a estrutura de diretórios é essencial para administrar um sistema Linux com segurança e eficiência.

Comandos Básicos do GNU/Linux

O terminal é uma poderosa ferramenta no GNU/Linux. Através dele, você pode navegar, manipular arquivos, gerenciar permissões, processos e muito mais. Abaixo, estão os comandos mais utilizados por iniciantes.

📁 Navegação no sistema

• pwd – Mostra o diretório atual
• cd NOME – Entra em um diretório
• cd .. – Volta um nível
• ls – Lista os arquivos e pastas do diretório
• ls -l – Lista em formato detalhado
• ls -a – Exibe arquivos ocultos

📂 Manipulação de arquivos e diretórios

• mkdir NOVA_PASTA – Cria uma nova pasta
• touch arquivo.txt – Cria um novo arquivo vazio
• cp origem destino – Copia arquivos
• mv origem destino – Move ou renomeia arquivos
• rm arquivo – Remove arquivos
• rm -r pasta – Remove diretórios recursivamente

🔍 Busca e ajuda

• find /caminho -name arquivo – Busca arquivos por nome
• grep "texto" arquivo – Busca por texto dentro de arquivos
• man comando – Manual do comando
• comando --help – Ajuda rápida sobre um comando

📜 Visualizar conteúdo de arquivos

• cat arquivo – Exibe conteúdo completo
• less arquivo – Exibe conteúdo paginado
• head -n 10 arquivo – Primeiras linhas
• tail -n 10 arquivo – Últimas linhas

⚙️ Outros úteis

• clear – Limpa o terminal
• history – Mostra os comandos utilizados
• sudo – Executa comandos como administrador
• reboot e shutdown – Reinicia ou desliga o sistema

# Criando uma pasta, entrando nela e criando um arquivo
mkdir projetos
cd projetos
touch resumo.txt
ls -l

Esses são apenas os primeiros passos. Com o tempo, você poderá usar pipes (|), redirecionamentos (>, >>), e montar scripts para automatizar tarefas. O terminal é seu aliado na produtividade!

Permissões no GNU/Linux

O GNU/Linux adota um sistema de permissões baseado em três categorias de usuários: proprietário (dono), grupo e outros. Para cada um, há três tipos de permissão:

• r – leitura (read)
• w – escrita (write)
• x – execução (execute)

Quando usamos o comando ls -l, vemos uma linha como esta:

-rwxr-xr--  1 jefer grupo  1024 mai 14 10:00 script.sh

Explicando:

• -: indica que é um arquivo (d para diretório)
• rwx: permissões do proprietário
• r-x: permissões do grupo
• r--: permissões para outros usuários

🔧 Modificando permissões com chmod

Você pode alterar permissões com letras (modo simbólico) ou números (modo octal):

✔️ Modo simbólico

chmod u+x script.sh     # adiciona permissão de execução para o dono
chmod g-w arquivo.txt   # remove permissão de escrita do grupo
chmod o+r log.txt       # dá permissão de leitura para outros

🔢 Modo octal

• 4 = leitura (r)
• 2 = escrita (w)
• 1 = execução (x)

As somas determinam os números:

chmod 755 script.sh  # rwxr-xr-x
chmod 644 arquivo.txt  # rw-r--r--

👤 Mudando dono e grupo

chown joao arquivo.txt       # muda o dono
chown joao:alunos arquivo.txt  # muda dono e grupo

🔒 Permissões especiais (avançado)

• setuid (s): executa com permissões do dono
• setgid (s): executa com permissões do grupo
• sticky bit (t): em diretórios como /tmp, impede que usuários apaguem arquivos de outros

chmod +t /publico   # ativa sticky bit
chmod u+s programa  # ativa setuid

Entender as permissões é essencial para manter a segurança e o controle de acesso em sistemas GNU/Linux.

Diagnóstico e Recuperação de Senha

Esqueceu a senha do root ou de um usuário no Linux? Veja como recuperar o acesso com métodos seguros, usados por administradores em situações reais.

🔎 Diagnóstico: Esqueceu a senha ou conta bloqueada?

• Verifique se o login está bloqueado:

  sudo faillock --user seu_usuario --show

  sudo passwd -S seu_usuario   # Mostra status da senha

• Desbloqueie a conta (se necessário):

  sudo passwd -u seu_usuario

🛠️ Recuperando senha pelo modo de recuperação (GRUB / modo single user)

1. Reinicie o computador.
2. No menu do GRUB, selecione a linha do seu sistema e pressione e para editar.
3. Procure pela linha que começa com linux e, ao final dela, adicione:
   init=/bin/bash
   Exemplo: linux ... ro quiet splash init=/bin/bash
4. Pressione Ctrl+X ou F10 para inicializar com essa configuração.
5. O sistema iniciará em modo de shell root. Remonte o sistema de arquivos como leitura/escrita:

   mount -o remount,rw /

6. Altere a senha:

   passwd root

   (ou para outro usuário: passwd usuario)
7. Sincronize alterações e reinicie:

   sync
   exec /sbin/init

   (ou apenas reboot -f)

💽 Recuperando senha via LiveCD/pendrive (usando chroot)

1. Inicie o computador por um LiveCD/pendrive de Linux.
2. Abra um terminal e descubra a partição do seu sistema:

   lsblk   # Procure algo como /dev/sda1, /dev/nvme0n1p2 etc.

3. Monte a partição principal:

   sudo mount /dev/sda1 /mnt   # Substitua pelo seu disco

4. (Opcional, para sistemas UEFI):

   sudo mount /dev/sda2 /mnt/boot/efi

5. Faça chroot para assumir o sistema instalado:

   sudo chroot /mnt

6. Altere a senha normalmente:

   passwd root

   passwd seu_usuario

7. Saia do chroot e desmonte:

   exit
   sudo umount /mnt
   sudo reboot

🔐 Dicas de segurança e prevenção

• Use senhas fortes e não compartilhe sua conta root!
• Desabilite boot por mídia removível em servidores críticos.
• Proteja o menu do GRUB com senha (guia oficial).
• Mantenha backups regulares de dados e configurações.

📚 Exercícios práticos

1. Simule a troca de senha root em uma VM usando o método do GRUB (init=/bin/bash).
2. Experimente alterar a senha via LiveCD e chroot.
3. Pesquise como proteger o GRUB com senha e configure em uma máquina de testes.
4. Bloqueie temporariamente um usuário (passwd -l usuario) e depois desbloqueie (passwd -u usuario).

Essas técnicas são valiosas para administradores, mas devem ser usadas com responsabilidade! Sempre proteja fisicamente servidores e mantenha políticas de segurança atualizadas.

chroot, sudo e su no GNU/Linux

🏠 chroot: Mudando o “raiz” do sistema

O comando chroot (change root) altera o diretório raiz (/) percebido por um processo e seus filhos. É usado para manutenção, recuperação de sistemas, ambientes isolados para testes ou instalação de softwares.
Exemplo prático: Recuperação do GRUB ou senha de root usando um LiveCD:

# Monte a partição do sistema (supondo /dev/sda1)
sudo mount /dev/sda1 /mnt
# (Monte também /dev, /proc, /sys, /run para total compatibilidade)
sudo mount --bind /dev /mnt/dev
sudo mount --bind /proc /mnt/proc
sudo mount --bind /sys /mnt/sys
sudo mount --bind /run /mnt/run
# Entra no ambiente raiz da instalação
sudo chroot /mnt
# Agora você pode rodar comandos como se estivesse naquele sistema:
passwd     # trocar senha de root
update-grub
grub-install /dev/sda
exit       # Sair do chroot
  

• Útil para reparar boot, senhas e arquivos críticos em sistemas “quebrados”.
• Cria ambientes “jail” para testes ou aumentar segurança em serviços (por exemplo, servidores web).

🔑 sudo: SuperUser DO

sudo permite executar comandos com privilégios de administrador (root), mas sem a necessidade de se logar como root. Vantagens: mais seguro, audita uso, permite delegar comandos específicos para usuários comuns.

sudo comando         # Executa comando como root
sudo apt update      # Atualiza pacotes (precisa de root)
sudo nano /etc/fstab # Edita arquivo protegido
sudo reboot          # Reinicia o sistema

Por padrão, sudo pede sua senha (não a do root) e registra o uso em logs (/var/log/auth.log). Para dar acesso personalizado, edite o arquivo /etc/sudoers com visudo.

jefer   ALL=(ALL:ALL) ALL
# Permite a usuário 'jefer' executar qualquer comando como root
# É possível restringir comandos, hosts, etc.

• Evite usar sudo su (muda para root, perdendo rastreabilidade).
• Use sudo -i para um shell root temporário.
• sudo !! repete o último comando com sudo.

👤 su: Substituir Usuário (Switch User)

O comando su (“substitute user” ou “switch user”) permite trocar para outro usuário, geralmente root, pedindo a senha desse usuário:

su           # Troca para root (requer senha do root)
su -         # Troca para root e carrega o ambiente do root
su usuario   # Troca para usuário especificado (senha desse usuário)

• Com su, o sistema não registra log do que você faz como root (menos seguro em ambientes multiusuário).
• Em sistemas modernos, sudo é recomendado para tarefas administrativas e logs de auditoria.
• Para voltar ao usuário anterior, digite exit.

💡 Diferenças e dicas rápidas

📚 Exercícios práticos

1. Use sudo para instalar um pacote qualquer (htop, por exemplo).
2. Edite um arquivo do sistema (/etc/hosts) usando sudo nano e depois tente sem sudo (deve falhar).
3. Crie um novo usuário e alterne para ele usando su e sudo su - novo_usuario.
4. Simule a recuperação de um sistema corrompido (pode ser uma VM) usando LiveCD + chroot para alterar a senha de root.
5. Altere permissões em /etc/sudoers (usando visudo) para dar acesso a um comando específico para um usuário padrão.

O domínio de chroot, sudo e su é fundamental para administradores e usuários avançados de GNU/Linux, tanto para recuperação de sistemas quanto para manter segurança e boas práticas!

Shell Script

Um shell script é um arquivo de texto com uma sequência de comandos que podem ser executados no terminal. Ele automatiza tarefas repetitivas e facilita a administração de sistemas GNU/Linux. O shell mais utilizado é o bash (Bourne Again SHell).

🧪 Primeiro script

#!/bin/bash
echo "Hello, mundo Linux!"

Salve com .sh, torne executável e execute:

chmod +x hello.sh
./hello.sh

🔄 Variáveis e entrada do usuário

#!/bin/bash
echo "Digite seu nome:"
read nome
echo "Olá, $nome! Bem-vindo ao GNU/Linux!"

🧭 Condicionais

#!/bin/bash
echo "Digite um número:"
read n
if [ $n -gt 10 ]; then
  echo "Maior que 10"
else
  echo "10 ou menor"
fi

🔁 Laços de repetição

#!/bin/bash
for i in {1..5}
do
  echo "Contando: $i"
done

📦 Criando scripts úteis

Exemplo de script que exibe o uso do disco:

#!/bin/bash
echo "Verificando uso do disco..."
df -h | grep "^/dev"

Shell scripts podem ser simples ou extremamente poderosos, integrando condições, loops, menus, e manipulação de arquivos e processos. São ferramentas essenciais para qualquer administrador ou usuário avançado de GNU/Linux.

Comandos Avançados no Linux

O GNU/Linux é um sistema operacional poderoso, especialmente na linha de comando, que oferece ferramentas avançadas para administração de sistemas, monitoramento, automação, análise de rede e depuração. Esta seção apresenta comandos essenciais para usuários avançados, organizados por categoria, com explicações detalhadas e exemplos práticos. Estes comandos são fundamentais para entender conceitos de sistemas operacionais, como gerenciamento de processos, memória, I/O, e comunicação em rede, além de serem úteis em cenários reais de administração de servidores.

🌐 Comandos de Rede

Comandos de rede permitem configurar, monitorar e depurar conexões, interfaces e tráfego de rede, fundamentais para entender protocolos como TCP/IP e o modelo de camadas do sistema operacional.

• ip a – Exibe informações sobre interfaces de rede e endereços IP configurados. Útil para verificar se uma interface (ex.: eth0, wlan0) está ativa e seus endereços IPv4/IPv6.
  Exemplo: ip a show eth0 – Mostra apenas a interface eth0.
• ping destino – Testa a conectividade com um host usando ICMP. Verifica latência e disponibilidade.
  Exemplo: ping -c 4 google.com – Envia 4 pacotes e exibe o resultado.
• ss -tuln – Lista sockets TCP/UDP em estado de escuta (listen). Ideal para verificar portas abertas.
  Exemplo: ss -tuln | grep 80 – Filtra portas relacionadas ao HTTP.
• tcpdump -i eth0 – Captura pacotes de rede em uma interface específica. Requer privilégios de root.
  Exemplo: sudo tcpdump -i eth0 port 80 – Captura tráfego HTTP na interface eth0.
• nmap 192.168.0.1 – Escaneia portas e serviços em um host. Útil para auditoria de segurança.
  Exemplo: nmap -sV 192.168.0.1 – Identifica versões de serviços nas portas abertas.
• nc -l -p 8080 – Inicia um servidor TCP simples na porta 8080. Útil para testes de conectividade.
  Exemplo: nc -l 8080 – Escuta conexões; em outro terminal, use nc localhost 8080 para conectar.
• curl -I http://example.com – Faz requisições HTTP e exibe cabeçalhos. Útil para depurar APIs ou sites.
  Exemplo: curl -I https://www.ufpr.br – Verifica o status HTTP do site da UFPR.
• dig dominio – Consulta DNS para obter informações sobre registros (ex.: A, MX, NS).
  Exemplo: dig www.google.com – Mostra o endereço IP associado ao domínio.
• netstat -i – Exibe estatísticas de interfaces de rede, como pacotes enviados/recebidos.
  Exemplo: netstat -i | grep eth0 – Filtra dados da interface eth0.
  
  

  🖥️ Monitoramento do Sistema

  Monitorar o sistema é essencial para entender o comportamento de recursos como CPU, memória, disco e processos, refletindo conceitos como escalonamento e alocação de recursos no sistema operacional.

  • top – Exibe processos em tempo real, com uso de CPU, memória e prioridade. Pressione q para sair.
    Exemplo: top – Monitora processos interativamente.
  • htop – Versão interativa do top, com interface gráfica e controles (instale com sudo apt install htop).
    Exemplo: htop --sort-key PERCENT_CPU – Ordena processos por uso de CPU.
  • vmstat – Relata estatísticas de memória virtual, CPU e I/O. Útil para análise de desempenho.
    Exemplo: vmstat 2 – Atualiza a cada 2 segundos.
  • iostat – Mostra estatísticas de entrada/saída (I/O) por dispositivo. Requer o pacote sysstat.
    Exemplo: iostat -d 2 – Monitora I/O de disco a cada 2 segundos.
  • dmesg – Exibe mensagens do kernel, úteis para diagnosticar problemas de hardware ou drivers.
    Exemplo: dmesg | grep -i error – Filtra mensagens de erro.
  • watch -n 2 comando – Executa um comando a cada 2 segundos, atualizando a saída.
    Exemplo: watch -n 5 df -h – Monitora o uso de disco a cada 5 segundos.
  • sar – Coleta e exibe estatísticas detalhadas do sistema (pacote sysstat). Útil para relatórios históricos.
    Exemplo: sar -u 1 5 – Mostra uso de CPU a cada segundo, 5 vezes.
  • iotop – Monitora I/O por processo em tempo real (instale com sudo apt install iotop).
    Exemplo: sudo iotop --only – Mostra apenas processos ativos com I/O.
  
  

  🧠 Memória, CPU e Processos

  Gerenciar processos e recursos como memória e CPU é central para entender o escalonador de processos e a alocação de memória no sistema operacional.

  • free -h – Mostra memória total, usada e livre em formato legível.
    Exemplo: free -h --si – Usa base 10 (MB/GB) em vez de base 2 (MiB/GiB).
  • ps aux – Lista todos os processos com detalhes (usuário, CPU, memória, comando).
    Exemplo: ps aux | grep python – Filtra processos relacionados ao Python.
  • kill PID – Envia um sinal (ex.: SIGTERM) para encerrar um processo pelo ID (PID).
    Exemplo: kill -9 1234 – Força o término do processo com PID 1234.
  • nice -n 10 comando – Executa um comando com prioridade ajustada (valores de -20 a 19; maior valor = menor prioridade).
    Exemplo: nice -n 15 make – Compila com baixa prioridade.
  • renice 10 -p PID – Altera a prioridade de um processo em execução.
    Exemplo: renice 10 -p 1234 – Ajusta a prioridade do processo 1234.
  • lsof -i – Lista arquivos abertos associados a conexões de rede.
    Exemplo: lsof -i :80 – Mostra processos usando a porta 80.
  • uptime – Exibe o tempo de atividade do sistema e a média de carga da CPU.
    Exemplo: uptime – Mostra carga média para 1, 5 e 15 minutos.
  • pstree – Exibe processos em uma estrutura de árvore, mostrando hierarquia.
    Exemplo: pstree -p – Inclui PIDs na árvore de processos.
  
  

  🔍 Texto, Logs e Análise

  Ferramentas de manipulação de texto são cruciais para processar logs e dados, refletindo a importância de pipelines e filtros em sistemas Unix.

  • grep "erro" /var/log/syslog – Busca padrões em arquivos de log.
    Exemplo: grep -i "fail" /var/log/auth.log – Busca falhas de autenticação, ignorando maiúsculas/minúsculas.
  • awk '{print $1, $2}' arquivo – Extrai e manipula colunas de texto.
    Exemplo: awk '{print $1}' /proc/meminfo – Extrai a primeira coluna de informações de memória.
  • sed 's/foo/bar/g' arquivo – Substitui texto em arquivos ou saída.
    Exemplo: sed -i 's/old/new/g' config.txt – Substitui no arquivo diretamente.
  • tail -f /var/log/syslog – Monitora logs em tempo real.
    Exemplo: tail -n 20 /var/log/syslog – Mostra as últimas 20 linhas.
  • cut -d',' -f1 arquivo.csv – Extrai campos de arquivos delimitados (ex.: CSV).
    Exemplo: cut -d',' -f1,3 dados.csv – Extrai a 1ª e 3ª colunas.
  • journalctl – Exibe logs do systemd, úteis para depuração de serviços.
    Exemplo: journalctl -u sshd – Mostra logs do serviço SSH.
  • zgrep "erro" /var/log/syslog.1.gz – Busca em arquivos de log compactados.
    Exemplo: zgrep -c "error" /var/log/syslog*.gz – Conta ocorrências de "error" em logs antigos.
  
  

  🗜️ Compactação e Arquivos

  Gerenciar arquivos e compactação é essencial para otimizar armazenamento e transferência, conceitos ligados à gestão de sistemas de arquivos no Linux.

  • tar -czf backup.tar.gz pasta/ – Cria um arquivo tar compactado com gzip.
    Exemplo: tar -czf backup_$(date +%F).tar.gz /home/user/docs – Inclui data no nome.
  • tar -xzf arquivo.tar.gz – Extrai um arquivo tar.gz.
    Exemplo: tar -xzf backup.tar.gz -C /tmp – Extrai para /tmp.
  • zip -r arq.zip pasta/ – Compacta uma pasta em formato ZIP.
    Exemplo: zip -r projetos.zip ~/projetos – Compacta a pasta projetos.
  • unzip arq.zip – Descompacta um arquivo ZIP.
    Exemplo: unzip arq.zip -d /tmp – Extrai para /tmp.
  • zstd -z arquivo – Compacta com Zstandard, mais rápido que gzip (instale com sudo apt install zstd).
    Exemplo: zstd -z large_file.txt – Gera large_file.txt.zst.
  • du -sh diretório – Calcula o tamanho de diretórios.
    Exemplo: du -sh /var/log – Mostra o tamanho total de /var/log.
  
  

  📦 Instalação de Pacotes

  Gerenciadores de pacotes como apt (Debian/Ubuntu) ou dnf (Fedora) são a interface do sistema operacional para instalar e atualizar software.

  • apt update && apt upgrade – Atualiza a lista de pacotes e instala atualizações (Debian/Ubuntu).
    Exemplo: sudo apt update && sudo apt full-upgrade – Inclui atualizações completas.
  • apt install pacote – Instala um pacote específico.
    Exemplo: sudo apt install nginx – Instala o servidor web Nginx.
  • apt search nome – Busca pacotes disponíveis.
    Exemplo: apt search python3 – Lista pacotes relacionados ao Python 3.
  • apt autoremove – Remove pacotes desnecessários.
    Exemplo: sudo apt autoremove --purge – Remove com configurações residuais.
  • dpkg -l – Lista pacotes instalados.
    Exemplo: dpkg -l | grep nginx – Filtra pacotes relacionados ao Nginx.
  
  

  📁 Cópias e Sincronização

  Cópias e sincronização de arquivos são cruciais para backups e transferências, ilustrando o uso de sistemas de arquivos distribuídos.

  • scp arquivo user@host:/caminho – Copia arquivos para um host remoto via SSH.
    Exemplo: scp backup.tar.gz user@192.168.0.2:/home/user – Copia para um servidor remoto.
  • rsync -avh origem/ destino/ – Sincroniza arquivos/diretórios com eficiência.
    Exemplo: rsync -avh ~/projetos /mnt/backup – Faz backup local.
  • rsync -e ssh -av pasta/ user@ip:/destino – Sincroniza via SSH.
    Exemplo: rsync -e ssh -av ~/docs user@server:/backup – Sincroniza com servidor remoto.
  • find /caminho -name "*.txt" – Busca arquivos por nome ou padrão.
    Exemplo: find /home -name "*.log" -exec cp {} /backup \; – Copia logs para backup.

  🕒 Agendamento de Tarefas

  O agendamento de tarefas via cron reflete a capacidade do sistema operacional de gerenciar execução periódica de processos.

  • crontab -e – Edita o arquivo de crontab do usuário para agendar tarefas.
    Exemplo: 0 2 * * * /backup.sh – Executa backup.sh às 2h diariamente.
  • crontab -l – Lista as tarefas agendadas do usuário.
    Exemplo: crontab -l > cron_backup.txt – Salva a lista em um arquivo.
  • @reboot comando – Executa um comando na inicialização do sistema.
    Exemplo: @reboot /usr/bin/update-system.sh – Executa script na inicialização.
  • systemctl enable nome-servico – Habilita um serviço para iniciar automaticamente.
    Exemplo: sudo systemctl enable nginx – Ativa o Nginx na inicialização.
  
  

  🧩 Ferramentas Úteis

  Ferramentas adicionais aumentam a produtividade e facilitam a administração do sistema.

  • tmux – Multiplexador de terminal para gerenciar múltiplas sessões. Instale com sudo apt install tmux.
    Exemplo: tmux new -s mysession – Cria uma sessão chamada mysession.
  • screen – Gerencia sessões de terminal persistentes.
    Exemplo: screen -S myscreen – Inicia uma sessão nomeada.
  • traceroute www.ufpr.br – Traça a rota de pacotes até um destino.
    Exemplo: traceroute -n www.google.com – Mostra IPs sem resolução DNS.
  • alias atualiza="sudo apt update && sudo apt upgrade" – Cria atalhos para comandos frequentes.
    Exemplo: echo 'alias ll="ls -la"' >> ~/.bashrc – Adiciona alias permanente.
  • bc – Calculadora de precisão arbitrária no terminal.
    Exemplo: echo "2.5 * 3.7" | bc – Calcula 2.5 × 3.7.
  • tee – Redireciona saída para arquivo e terminal simultaneamente.
    Exemplo: ls -l | tee output.txt – Salva a saída e exibe no terminal.
  
  

  🛠️ Prática Guiada: Configurando Monitoramento e Backup

  Esta prática guiada simula a administração de um servidor Linux, ensinando a monitorar recursos, configurar backups automáticos e analisar logs. É ideal para alunos de Sistemas Operacionais, pois conecta comandos a conceitos práticos como processos, I/O e automação.

  Prática 1: Monitorando o Sistema

  
  # 1. Verifique o uso de memória e CPU
  free -h
  top  # Pressione 'q' para sair
  htop  # Instale com 'sudo apt install htop' se necessário
  
  # 2. Liste processos consumindo mais CPU
  ps aux --sort=-%cpu | head -n 5
  
  # 3. Monitore o uso de disco a cada 5 segundos
  watch -n 5 df -h
  
  # 4. Verifique mensagens recentes do kernel
  sudo dmesg | tail -n 20
      

  Prática 2: Configurando Backup Automático

  
  # 1. Crie um script de backup
  echo '#!/bin/bash
  rsync -avh ~/projetos /mnt/backup/$(date +%F)
  tar -czf /mnt/backup/backup_$(date +%F).tar.gz ~/projetos' > backup.sh
  chmod +x backup.sh
  
  # 2. Teste o script
  ./backup.sh
  
  # 3. Agende o backup para rodar às 2h diariamente
  crontab -e
  # Adicione a linha abaixo no editor:
  0 2 * * * /home/user/backup.sh
  
  # 4. Verifique tarefas agendadas
  crontab -l
      

  Prática 3: Analisando Logs de Rede

  
  # 1. Liste portas abertas
  ss -tuln
  
  # 2. Capture tráfego HTTP (requer root)
  sudo tcpdump -i eth0 port 80 -c 10
  
  # 3. Busque erros em logs de autenticação
  sudo grep -i "fail" /var/log/auth.log
  
  # 4. Monitore logs do sistema em tempo real
  sudo tail -f /var/log/syslog
      

  Estes comandos e práticas são ferramentas poderosas para administração de sistemas Linux. Dominá-los permite gerenciar servidores com eficiência, aplicar conceitos de sistemas operacionais (como escalonamento, redes e sistemas de arquivos) e resolver problemas reais. Para alunos, experimente combinar esses comandos em pipelines (ex.: ps aux | grep nginx | awk '{print $2}' | xargs kill) para automações avançadas.

  📚 Dicas:

  • Pratique em um ambiente virtualizado (ex.: VirtualBox, WSL2) para evitar erros em sistemas reais.
  • Use man comando ou comando --help para aprender opções adicionais.
  • Combine comandos com pipes (|) para criar fluxos de trabalho eficientes.
  • Explore ferramentas como tmux para gerenciar sessões de terminal em servidores remotos.

Boot, GRUB e Cron no GNU/Linux

🚀 Processo de Boot

📝 O que é o GRUB?

GRUB (GRand Unified Bootloader) é o carregador de boot padrão do GNU/Linux moderno. Ele gerencia:

• Escolha entre múltiplos sistemas operacionais (dual boot)
• Seleção de versões do kernel
• Configuração de opções de inicialização e recuperação

# Na tela do GRUB, pressione 'e' para editar a entrada.
# Modifique a linha do kernel (ex: adicione 'single' para modo manutenção).
# Pressione Ctrl+X ou F10 para inicializar com as opções editadas.

O arquivo principal de configuração é /etc/default/grub. Após alterações:

sudo update-grub    # Debian/Ubuntu
sudo grub2-mkconfig -o /boot/grub2/grub.cfg    # Fedora/Red Hat

🛠️ Troubleshooting: Resgate e Recuperação de Boot

• Modo de recuperação: Na tela do GRUB, escolha "Advanced options" → "recovery mode" para reparar o sistema, redefinir senhas ou corrigir arquivos.
• Chroot: Use chroot a partir de um LiveCD para “entrar” no seu sistema instalado e reparar o GRUB ou outros problemas:

  sudo mount /dev/sda1 /mnt
  sudo mount --bind /dev /mnt/dev
  sudo mount --bind /proc /mnt/proc
  sudo mount --bind /sys /mnt/sys
  sudo chroot /mnt
  grub-install /dev/sda
  update-grub

• Reinstalando o GRUB: Se o GRUB sumir (aparece “grub rescue” ou só “_”), inicialize por um LiveCD e rode:

  sudo mount /dev/sda1 /mnt
  sudo grub-install --root-directory=/mnt /dev/sda
  sudo update-grub

Dica: Se alterar UUIDs, dispositivos ou partições, confira e ajuste seu /etc/fstab para evitar erros de montagem no boot!

🖇️ Automontagem de Partições: /etc/fstab

O /etc/fstab especifica o que será montado automaticamente no boot:

UUID=abcd-1234   /mnt/dados   ext4   defaults   0  2

• UUID: Identificador da partição (descubra com blkid)
• Ponto de montagem: Ex: /mnt/dados
• Sistema de arquivos: ext4, ntfs, etc.
• Opções: defaults, noauto, ro, etc.

sudo mount -a  # Monta tudo do fstab (após editar)

⏰ Agendamento de tarefas com Cron

O cron é o serviço para agendamento recorrente de tarefas. Com o comando crontab -e você edita tarefas do seu usuário:

# min  hora  diaMês  mês  diaSemana  comando
0     2     *      *    *         /home/usuario/scripts/backup.sh  # 2h todo dia

• * = qualquer valor possível no campo
• Agende com diferentes frequências: cada minuto, toda segunda, etc.
• Para agendar como root: sudo crontab -e
• Veja tarefas do usuário: crontab -l

Ferramentas complementares:

• at: Agende tarefas únicas no futuro: echo "shutdown -r now" | at 23:00
• anacron: Executa tarefas periódicas mesmo se o computador ficou desligado.

0 5 * * 0 /home/usuario/scripts/backup_semanal.sh

sudo tail -f /var/log/syslog    # Debian/Ubuntu
sudo tail -f /var/log/cron      # Fedora/Red Hat

📚 Exercícios Práticos

1. Altere uma linha do GRUB para iniciar em modo texto (adicione 3 ao final da linha do kernel).
2. Monte manualmente uma partição em /mnt/teste e adicione sua entrada ao /etc/fstab.
3. Agende uma tarefa para criar um arquivo /tmp/teste.txt todo dia às 7h.
4. Simule um problema de boot trocando um UUID do fstab e resolva pelo LiveCD usando chroot.
5. Use o comando at para reiniciar o sistema em 1 hora.

Dicas e Observações

• É possível restaurar bootloader perdido usando um LiveCD e chroot.
• Sempre faça backup do /etc/fstab antes de editar.
• Testar mount -a antes de reiniciar previne problemas de montagem.
• Use crontab.guru para testar expressões do cron.

Entender o processo de boot, GRUB, automontagem e agendamento de tarefas é essencial para qualquer administrador Linux ou profissional de sistemas operacionais!

Firewall no GNU/Linux

O firewall é uma das primeiras linhas de defesa em sistemas operacionais. No Linux, o firewall atua controlando o tráfego de rede, permitindo ou bloqueando conexões de acordo com regras definidas pelo usuário ou administrador.

🔥 Principais ferramentas de firewall no Linux

• iptables: Ferramenta tradicional, poderosa e flexível para definir regras de firewall manualmente.
• ufw (Uncomplicated Firewall): Interface mais simples para gerenciamento de firewall, comum no Ubuntu e derivados.
• firewalld: Sistema dinâmico de gerenciamento de firewall, utilizado em Fedora, CentOS e RHEL.

🛡️ Exemplos práticos de uso

Comando UFW (Ubuntu, Mint, etc.)

sudo ufw status                # Verificar status do firewall
sudo ufw enable                # Ativar o firewall
sudo ufw disable               # Desativar o firewall
sudo ufw allow 22/tcp          # Liberar porta SSH (22)
sudo ufw deny 80/tcp           # Bloquear acesso à porta 80 (HTTP)
sudo ufw delete allow 22/tcp   # Remover regra específica

Comando firewalld (Fedora, CentOS, RHEL)

sudo firewall-cmd --state                            # Verificar status
sudo firewall-cmd --add-service=ssh --permanent      # Liberar SSH permanentemente
sudo firewall-cmd --remove-service=ftp --permanent   # Bloquear FTP
sudo firewall-cmd --reload                           # Aplicar alterações

Comando iptables (tradicional, avançado)

sudo iptables -L                         # Listar regras
sudo iptables -A INPUT -p tcp --dport 22 -j ACCEPT    # Liberar SSH
sudo iptables -A INPUT -j DROP            # Bloquear todas as outras conexões
sudo iptables-save > /etc/iptables/rules.v4  # Salvar regras

🔎 Dicas e observações

• Ative o firewall sempre que expuser o sistema à Internet ou a redes não confiáveis.
• Permita portas e serviços essenciais para seu uso (exemplo: 22 para SSH, 80 para HTTP).
• Sempre teste o acesso remoto antes de bloquear serviços críticos, para não perder acesso!
• Em servidores, é prática comum bloquear tudo por padrão e liberar apenas o necessário ("política de menor privilégio").
• Logs de firewall podem ser encontrados em /var/log/ufw.log ou /var/log/messages dependendo da ferramenta usada.

sudo ufw default deny incoming
sudo ufw allow 22/tcp
sudo ufw enable

Praticar o uso do firewall em laboratório é essencial para quem administra sistemas GNU/Linux!

Benchmark e Tuning de Desempenho no GNU/Linux

Benchmark é o processo de medir o desempenho de hardware ou software para comparação, diagnóstico ou ajuste. Tuning refere-se à otimização do sistema para atingir o melhor desempenho possível em determinada tarefa ou ambiente.

🛠️ Principais ferramentas de benchmark

• sysbench: Testa CPU, memória, disco e banco de dados.
• stress: Gera carga sintética na CPU, memória ou disco para teste de estabilidade.
• hdparm: Mede velocidade de leitura de discos.
• fio: Benchmark avançado de I/O em disco.
• iperf: Mede desempenho de rede entre dois hosts.
• glmark2: Mede desempenho gráfico (GPU/OpenGL).

📊 Exemplos práticos

sudo apt install sysbench
sysbench cpu --cpu-max-prime=20000 run

sudo apt install stress
stress --cpu 2 --io 1 --vm 1 --timeout 30

sudo hdparm -Tt /dev/sda

sudo apt install iperf3
iperf3 -s    # Em um computador (servidor)
iperf3 -c IP_DO_SERVIDOR   # No outro computador (cliente)

⚙️ Tuning: Ajustando o desempenho do sistema

• Prioridades de processo: Use nice e renice para ajustar prioridades:

  nice -n 10 comando   # Executa com prioridade menor
  renice -n -5 -p 1234 # Aumenta prioridade do processo PID 1234
  

• Ajustando parâmetros do kernel:

  sysctl -a                # Lista todos os parâmetros
  sudo sysctl -w vm.swappiness=10  # Reduz o uso de swap

• Dicas rápidas:
  • Feche programas não usados e desabilite serviços desnecessários
  • Monitore o uso de recursos em tempo real com htop ou glances
  • Para servidores, mantenha drivers e kernel atualizados

💡 Exercícios práticos

1. Faça um benchmark da CPU do seu sistema com sysbench e salve o resultado.
2. Teste a velocidade de leitura do seu disco usando hdparm ou fio.
3. Gere carga no sistema com stress e monitore em tempo real com htop.
4. Altere o valor de vm.swappiness e observe o comportamento da memória.
5. Teste a largura de banda de rede entre dois computadores com iperf3.

Medir e otimizar desempenho é fundamental para garantir a eficiência de sistemas GNU/Linux, seja em desktops, laboratórios ou servidores!

Automontagem, Diagnóstico e Gerenciamento de Discos

Gerenciar dispositivos de armazenamento no GNU/Linux envolve entender como o sistema reconhece, monta e diagnostica discos, partições e dispositivos removíveis (pendrives, HDs externos). A automontagem facilita o uso diário, enquanto comandos avançados ajudam a identificar, reparar e otimizar discos.

🔗 Automontagem de Dispositivos

• /etc/fstab: Arquivo central para definir pontos de montagem permanentes. Ajuste UUID, tipo de sistema de arquivos e opções de montagem para cada partição.
• udisksctl: Ferramenta moderna para montar/desmontar dispositivos de forma interativa e sem privilégios de root.

  udisksctl mount -b /dev/sdb1      # Monta partição
  udisksctl unmount -b /dev/sdb1    # Desmonta partição
  udisksctl status                  # Mostra dispositivos e status
        

• GNOME Disks (gnome-disks): Interface gráfica para partições, montagem automática e benchmarks.
• udev: Sistema de gerenciamento dinâmico de dispositivos do kernel. Usado para criar regras automatizadas (ex: montar um HD específico sempre em /mnt/dados).

Exemplo de regra do udev:

# /etc/udev/rules.d/99-usb.rules
KERNEL=="sd*", SUBSYSTEMS=="usb", ACTION=="add", RUN+="/usr/bin/mount /dev/%k /media/usb"
  

Regras do udev são avançadas e podem automatizar montagem, permissões e até execução de scripts ao plugar dispositivos.

🩺 Diagnóstico e Solução de Problemas de Disco

• blkid: Lista UUIDs e tipos de sistemas de arquivos dos dispositivos.
  sudo blkid
• lsblk -f: Mostra partições, pontos de montagem, tipos de FS e UUID.
• parted: Gerencia e ajusta partições em discos grandes.
  sudo parted /dev/sda print
• fsck: Verifica e repara sistemas de arquivos.
  sudo fsck /dev/sda1
• badblocks: Verifica setores defeituosos em discos.
  sudo badblocks -v /dev/sda1
• smartctl: Mostra status S.M.A.R.T. de discos modernos, útil para prever falhas.
  sudo smartctl -a /dev/sda
• mount/umount: Monta e desmonta sistemas de arquivos manualmente.
• findmnt: Exibe todos os sistemas de arquivos atualmente montados.
  findmnt
• df -Th: Espaço livre, tipos de FS e pontos de montagem.
• du -h --max-depth=1: Espaço ocupado por subdiretórios.
• dd: Usado para copiar, clonar e testar dispositivos de bloco (atenção: uso perigoso!).
  sudo dd if=/dev/zero of=/dev/sdb bs=1M count=100 (zera 100MB no /dev/sdb)
• wipefs: Limpa assinaturas de sistemas de arquivos, útil para reparticionar discos.
  sudo wipefs -a /dev/sdb1
• partprobe: Atualiza a tabela de partições do kernel sem reboot.
  sudo partprobe
• ntfs-3g: Monta partições NTFS.
  sudo ntfs-3g /dev/sdXN /mnt/ntfs

🖼️ Esquema: Como ocorre a montagem de um dispositivo no Linux

Fonte: Wikimedia Commons – O kernel detecta o dispositivo (udev), atribui identificadores (blkid, lsblk), a automontagem pode ser feita via fstab, udisksctl, desktop, ou manualmente pelo usuário.

📋 Mini-guia: Backup, Recuperação e Reparticionamento Seguro

• Antes de alterar partições/discos:
  • Faça backup dos dados importantes usando rsync ou cp.
  • Para backup completo do disco:
    sudo dd if=/dev/sdX of=/caminho/backup.img bs=4M status=progress
  • Verifique integridade do backup antes de modificar!
• Recuperando arquivos ou partições perdidas:
  • Use testdisk (sudo apt install testdisk) para tentar recuperar partições deletadas.
  • Use photorec (vem junto) para recuperar arquivos perdidos em partições corrompidas.
• Reparticionando discos:
  • Ferramentas gráficas como gnome-disks ou gparted são mais seguras para iniciantes.
  • No terminal, use parted, fdisk ou cfdisk.
  • Após alterar partições, rode sudo partprobe para atualizar tabelas sem reiniciar.
  • Revise e ajuste entradas no /etc/fstab para refletir UUIDs e pontos de montagem atualizados.
• Restaurando backup com dd:
  • sudo dd if=/caminho/backup.img of=/dev/sdX bs=4M status=progress
  • Atenção: sempre confira o dispositivo de destino!

#!/bin/bash
origem="/dev/sdb1"
destino="/mnt/backup/backup-$(date +%F).img"
echo "Iniciando backup de $origem para $destino"
sudo dd if=$origem of=$destino bs=4M status=progress
sync
echo "Backup concluído!"
    

# Salve como /etc/udev/rules.d/99-auto-usb.rules
KERNEL=="sd[b-z][1-9]", ACTION=="add", RUN+="/usr/bin/udisksctl mount -b /dev/%k"
    

gnome-disks    # Utilitário gráfico (em GNOME)
sudo gparted   # Editor gráfico de partições universal
    

📚 Exercícios práticos

1. Liste todos os discos, partições e UUIDs do sistema com lsblk -f e blkid.
2. Monte manualmente um pendrive usando udisksctl e depois pelo comando mount.
3. Simule e corrija um erro em /etc/fstab usando LiveCD.
4. Verifique o status S.M.A.R.T. do seu HD com smartctl.
5. Encontre e corrija bad blocks em uma partição de teste usando badblocks e fsck.
6. Crie e teste uma regra simples de udev para montar um HD em uma pasta específica automaticamente.

Entender automontagem, diagnóstico e gerenciamento de discos é essencial para resolver problemas reais e garantir a integridade de dados em sistemas GNU/Linux!

Gerenciamento de Logs e Monitoramento

O gerenciamento de logs é fundamental para diagnosticar problemas, auditar acessos, detectar falhas e garantir a segurança em sistemas Linux. Além disso, monitorar recursos do sistema (CPU, memória, disco, rede) é essencial para administração eficiente.

📖 Logs do sistema: journalctl, rsyslog e logrotate

• journalctl: Ferramenta para visualizar logs mantidos pelo systemd (presente em quase todas as distros modernas).

  # Ver todos os logs do sistema (pode ser muito extenso)
  journalctl
  
  # Logs desde o último boot
  journalctl -b
  
  # Logs de um serviço específico (exemplo: sshd)
  journalctl -u ssh
  
  # Filtrando por data/hora
  journalctl --since "2024-05-20 08:00" --until "2024-05-20 12:00"
  
  # Seguindo logs em tempo real (como tail -f)
  journalctl -f
        

• rsyslog: Sistema tradicional de logs, grava arquivos em /var/log/ (ex: /var/log/syslog, /var/log/auth.log).
  • Editando /etc/rsyslog.conf, você pode personalizar roteamento e formatos dos logs.
  • Exemplo de leitura de logs:

    # Erros de autenticação
    cat /var/log/auth.log | grep 'Failed'
    # Últimos 20 logs de kernel
    tail -n 20 /var/log/kern.log
              

• logrotate: Gerencia rotação, compressão e exclusão automática de arquivos de log para evitar que ocupem muito espaço.
  • Configuração: /etc/logrotate.conf e /etc/logrotate.d/
  • Forçar rotação manual:

    sudo logrotate -f /etc/logrotate.conf

🔍 Dicas para consultar e filtrar logs

• Use grep, less, awk para buscas avançadas:

  grep "error" /var/log/syslog
  less +F /var/log/syslog   # "tail" interativo, pressione Ctrl+C para parar
  awk '{print $1, $2, $5}' /var/log/syslog | head -20
        

• Combine logs com pipes e condições para auditoria e troubleshooting.

🖥️ Monitoramento em tempo real (CLI)

• top — Visualização geral de processos, uso de CPU/memória
• htop — Versão mais visual, colorida e interativa do top (sudo apt install htop)
• glances — Painel completo com info de CPU, RAM, disco, rede (sudo apt install glances)
• atop — Foco em análise histórica e detalhada de recursos (sudo apt install atop)
• nmon — Gráficos em modo texto para análise detalhada (sudo apt install nmon)
• iotop — Monitoramento de uso de disco por processo (sudo apt install iotop)
• Exemplos:

  htop       # Para visualizar processos com cores e interação
  glances    # Resumo de recursos do sistema
  atop       # Histórico detalhado, ótimo para auditoria pós-incidente
  nmon       # Inicia interface, pressione letras para navegar
  iotop      # Monitora escrita/leitura em disco em tempo real
        

🖼️ Monitoramento Gráfico (GUI)

• KSysGuard (KDE) — Monitor completo de processos, gráficos de uso, alertas.
• GNOME System Monitor — Visualização de processos, uso de CPU, memória, rede.
• Stacer — Painel gráfico bonito e completo (sudo apt install stacer).
• Netdata — Monitoramento web em tempo real (avançado, veja aqui).

📚 Exercícios práticos

1. Liste todos os logs de falha de autenticação do último boot (journalctl -b -p err | grep 'authentication').
2. Rode o htop ou glances e capture um print mostrando uso de CPU, RAM e disco.
3. Simule um erro (ex: senha errada no sudo), ache o log correspondente no journalctl ou /var/log/auth.log.
4. Verifique a política de rotação dos logs usando cat /etc/logrotate.conf e ls /etc/logrotate.d/.
5. Instale o stacer e explore recursos de monitoramento gráfico.

Saber interpretar logs e monitorar recursos em tempo real é uma das habilidades mais valorizadas para quem administra ou utiliza sistemas GNU/Linux em ambientes profissionais!

Criação e Gerenciamento de Serviços (systemd)

O systemd é o sistema padrão de inicialização e gerenciamento de serviços da maioria das distribuições GNU/Linux modernas. Ele permite iniciar, parar, habilitar e monitorar serviços de forma centralizada.

⚙️ Comandos essenciais do systemd

• sudo systemctl start NOME — Inicia um serviço imediatamente
• sudo systemctl stop NOME — Para um serviço
• sudo systemctl restart NOME — Reinicia o serviço
• sudo systemctl status NOME — Mostra status detalhado
• sudo systemctl enable NOME — Ativa o serviço no boot
• sudo systemctl disable NOME — Remove do boot
• sudo systemctl list-units --type=service — Lista todos os serviços ativos

📝 Criando um serviço customizado (.service)

1. Crie um script a ser executado como serviço (exemplo: backup simples):

   #!/bin/bash
   tar -czf /home/$USER/backup-$(date +%F).tar.gz /home/$USER/documentos

   Salve como /home/$USER/scripts/backup.sh e torne executável:

   chmod +x /home/$USER/scripts/backup.sh

2. Crie o arquivo de serviço:

   sudo nano /etc/systemd/system/backup.service

   
   [Unit]
   Description=Backup diário dos documentos do usuário
   
   [Service]
   Type=oneshot
   User=seu_usuario
   ExecStart=/home/seu_usuario/scripts/backup.sh
   
   [Install]
   WantedBy=multi-user.target
         

   Dicas: - Substitua seu_usuario pelo seu usuário real. - Type=oneshot é ideal para tarefas que rodam e terminam.

3. Recarregue o systemd e teste:

   sudo systemctl daemon-reload
   sudo systemctl start backup.service
   sudo systemctl status backup.service

4. Habilite para rodar no boot (opcional):

   sudo systemctl enable backup.service

🕒 Rodando serviços automaticamente em horários agendados

• Para agendar, prefira um timer do systemd ao invés do cron:

sudo nano /etc/systemd/system/backup.timer

[Unit]
Description=Agendamento do backup diário

[Timer]
OnCalendar=*-*-* 03:00:00
Persistent=true

[Install]
WantedBy=timers.target
    

• Ative o timer:

sudo systemctl daemon-reload
sudo systemctl enable --now backup.timer
    

• Veja timers ativos:

  systemctl list-timers

📖 Logs dos serviços (journalctl)

• Para ver os logs do seu serviço:

  journalctl -u backup.service
  # Ou apenas as últimas entradas:
  journalctl -u backup.service -n 20
        

• Adicione StandardOutput=append:/var/log/backup.log em [Service] se quiser registrar em arquivo específico.

📚 Exercícios práticos

1. Crie um serviço que rode qualquer script personalizado no boot e monitore seu status.
2. Crie um timer que execute um script de backup todos os dias às 3h da manhã.
3. Use o journalctl para verificar logs de serviços, encontrando mensagens de erro.
4. Altere um serviço e faça reload do systemd para aplicar mudanças.

O domínio do systemd permite automatizar, monitorar e administrar tarefas críticas do sistema com precisão e confiabilidade!

Serviços LAMP: Linux, Apache, MySQL/MariaDB, PHP

LAMP é um acrônimo para um conjunto de softwares livres amplamente utilizado para hospedagem de aplicações web:

• Linux – sistema operacional
• Apache – servidor web
• MySQL/MariaDB – sistema de banco de dados
• PHP – linguagem de scripts para web (também pode ser Perl ou Python)

🖥️ Instalando o LAMP no Ubuntu/Debian

1. Atualize o sistema:

   sudo apt update && sudo apt upgrade

2. Instale o Apache:

   sudo apt install apache2

   Acesse http://localhost no navegador para testar.

3. Instale o MySQL ou MariaDB:

   sudo apt install mysql-server

   Recomenda-se executar o assistente de segurança:
   sudo mysql_secure_installation

4. Instale o PHP (e módulos recomendados):

   sudo apt install php libapache2-mod-php php-mysql

   Crie um arquivo /var/www/html/info.php com:
   <?php phpinfo(); ?>
   Acesse http://localhost/info.php para ver a página de teste.

🔧 Comandos úteis de administração

• sudo systemctl status apache2 – Verifica status do Apache
• sudo systemctl restart apache2 – Reinicia o Apache
• sudo systemctl status mysql – Verifica status do MySQL/MariaDB
• sudo mysql – Acessa o terminal do banco de dados
• mysql -u root -p – Login manual no MySQL/MariaDB
• php -v – Checa versão do PHP

💡 Dicas de segurança

• Altere a senha do root do MySQL/MariaDB logo após a instalação.
• Remova ou restrinja o acesso ao info.php depois do teste – ele expõe informações sensíveis do servidor.
• Mantenha o firewall ativado (UFW ou firewalld) e permita apenas as portas necessárias (ex: 80 para HTTP, 443 para HTTPS).
• Desabilite diretórios de listagem no Apache editando /etc/apache2/apache2.conf ou /etc/apache2/conf-enabled/.
• Faça backup regular dos bancos de dados com mysqldump ou mariadb-dump.

🗂️ Estrutura padrão de diretórios

• /var/www/html – Diretório padrão dos sites
• /etc/apache2/ – Configuração do Apache
• /etc/mysql/ ou /etc/mysql/mariadb.conf.d/ – Configuração do MySQL/MariaDB
• /var/lib/mysql/ – Dados do banco de dados
• /etc/php/ – Configuração do PHP

📚 Exercícios práticos

1. Instale o ambiente LAMP em uma VM ou computador com Ubuntu/Debian.
2. Crie um site simples em HTML e PHP em /var/www/html e teste pelo navegador.
3. Crie um banco de dados, uma tabela simples e insira alguns registros usando o MySQL/MariaDB.
4. Implemente um formulário em PHP que leia dados do banco e mostre na tela.
5. Realize um backup do banco usando mysqldump e depois restaure.
6. Pesquise como instalar o phpMyAdmin para administração gráfica e teste o acesso.

O domínio dos serviços LAMP é essencial para quem deseja atuar com administração de servidores Linux, desenvolvimento web ou hospedagem de sites profissionais.

🌐 Configurando Virtual Hosts (Múltiplos Sites) no Apache

Virtual hosts permitem hospedar mais de um site/domínio em um mesmo servidor. Exemplo prático para meusite.local:

1. Crie um diretório para o novo site:

   sudo mkdir -p /var/www/meusite.local

2. Defina permissões:

   sudo chown -R $USER:$USER /var/www/meusite.local

3. Crie um arquivo de configuração:

   sudo nano /etc/apache2/sites-available/meusite.local.conf

   
   
       ServerAdmin webmaster@meusite.local
       ServerName meusite.local
       DocumentRoot /var/www/meusite.local
       ErrorLog ${APACHE_LOG_DIR}/meusite_error.log
       CustomLog ${APACHE_LOG_DIR}/meusite_access.log combined
   
       

4. Ative o site e reinicie o Apache:

   
   sudo a2ensite meusite.local.conf
   sudo systemctl reload apache2
       

5. Adicione o domínio em /etc/hosts (para acesso local):

   
   sudo nano /etc/hosts
   # Adicione a linha:
   127.0.0.1   meusite.local
       

Acesse http://meusite.local no navegador para testar. Dica: Repita para quantos domínios quiser!

🛠️ Instalando o phpMyAdmin

1. Instale o phpMyAdmin:

   sudo apt install phpmyadmin

   Durante a instalação, escolha Apache2 e configure a senha do banco de dados quando solicitado.

2. Verifique se existe o link simbólico:

   ls /usr/share/phpmyadmin

   Em geral, o acesso é via http://localhost/phpmyadmin.

3. Se necessário, crie o link manualmente:

   
   sudo ln -s /usr/share/phpmyadmin /var/www/html/phpmyadmin
       

Dica de segurança: Restrinja o acesso ao phpMyAdmin, edite /etc/apache2/conf-available/phpmyadmin.conf para liberar só IPs específicos, ou use autenticação adicional.
Nunca exponha o phpMyAdmin publicamente sem senha forte e firewall ativo!

🔒 Integrando Firewall (UFW) ao LAMP

Permita apenas as portas essenciais:

sudo ufw allow 80/tcp      # HTTP
sudo ufw allow 443/tcp     # HTTPS (SSL/TLS)
sudo ufw allow 3306/tcp    # MySQL (apenas se realmente necessário para acesso remoto!)
sudo ufw enable            # Ative o firewall, se ainda não estiver ativo
sudo ufw status            # Confira as regras ativas

Dica: Para máxima segurança, mantenha a porta 3306 (MySQL) bloqueada para redes externas; só permita localmente ou para IPs restritos.

💾 Script de backup automático de banco de dados

#!/bin/bash
DATA=$(date +%F-%H%M)
ARQUIVO="/home/$USER/backup-mysql-$DATA.sql"
mysqldump -u root -pSENHA --all-databases > "$ARQUIVO"
gzip "$ARQUIVO"
echo "Backup completo: $ARQUIVO.gz"
  

Dica: - Programe o script no cron para executar diariamente ou semanalmente.
- Nunca armazene a senha em texto plano em scripts de produção (use ~/.my.cnf para credenciais seguras).
- Envie backups para outro servidor/drive para máxima segurança!

Compartilhamento de Arquivos com Samba

Samba é um conjunto de ferramentas que permite o compartilhamento de arquivos e impressoras entre sistemas GNU/Linux, Windows e macOS usando o protocolo SMB/CIFS (usado nativamente pelo Windows). Ele é fundamental em ambientes corporativos e domésticos para integração de redes mistas.

🛠️ Instalando o Samba

sudo apt update
sudo apt install samba samba-common

O serviço principal é o smbd. Verifique se está ativo:

sudo systemctl status smbd

📂 Configuração Básica de Compartilhamento

1. Crie um diretório para compartilhar, por exemplo:

   sudo mkdir -p /srv/samba/publico
   sudo chown nobody:nogroup /srv/samba/publico
   sudo chmod 0777 /srv/samba/publico

2. Edite o arquivo de configuração:

   sudo nano /etc/samba/smb.conf

   Adicione ao final:

   
   [Publico]
      path = /srv/samba/publico
      browseable = yes
      read only = no
      guest ok = yes
   

3. Reinicie o serviço Samba:

   sudo systemctl restart smbd

4. Agora o compartilhamento está disponível na rede local como \\seu-ip\Publico.
   No Windows, acesse pelo Explorer: \\192.168.1.10\Publico

🔐 Compartilhamento com Usuário e Senha (mais seguro)

• Crie um usuário local Linux e registre-o no Samba:

  sudo adduser aluno
  sudo smbpasswd -a aluno

• Exemplo de configuração no smb.conf:

  
  [Privado]
     path = /srv/samba/privado
     valid users = aluno
     guest ok = no
     read only = no
  

• No Windows, conecte usando o usuário e senha cadastrados.

🔧 Comandos úteis para administração

• sudo smbstatus — Mostra conexões ativas e arquivos abertos
• sudo testparm — Valida o arquivo de configuração do Samba
• smbclient -L //localhost/ -U aluno — Lista compartilhamentos disponíveis
• sudo pdbedit -L — Lista usuários Samba
• sudo ufw allow samba — Libera portas do Samba no firewall

💡 Dicas de segurança

• Evite compartilhamentos com guest ok = yes em redes abertas.
• Restrinja permissões das pastas de acordo com a necessidade (use chown, chmod).
• Monitore acessos com smbstatus e logs em /var/log/samba/.
• Considere autenticação por usuário e senha mesmo em ambientes domésticos.

🚑 Solução de problemas (troubleshooting)

• Se o compartilhamento não aparece no Windows:
  • Verifique firewall (sudo ufw allow samba)
  • Confirme o grupo de trabalho (workgroup)
  • Reinicie serviços (sudo systemctl restart smbd nmbd)
• Use testparm para checar erros de sintaxe no smb.conf.
• Consulte logs em /var/log/samba/ para detalhes de erros.
• Certifique-se de que o Windows está na mesma sub-rede e grupo de trabalho.

📚 Exercícios práticos

1. Configure um compartilhamento público e outro restrito por usuário.
2. Acesse o compartilhamento a partir de uma máquina Windows ou outro Linux (smbclient).
3. Altere permissões e teste acessos de diferentes usuários.
4. Liste e monitore conexões ativas usando smbstatus.
5. Desafie-se: Crie um script que faça backup diário de uma pasta compartilhada.

O domínio do Samba amplia as possibilidades de integração de sistemas em redes mistas, tornando o GNU/Linux uma solução completa para servidores de arquivos em ambientes domésticos ou corporativos.

🔗 Montando compartilhamento Samba automaticamente (fstab)

Para montar uma pasta Samba (ex: \\servidor\publico) automaticamente em cada boot do Linux:

1. Crie um ponto de montagem:

   sudo mkdir -p /mnt/publico

2. Crie (opcional) um arquivo com as credenciais:

   
   sudo nano /etc/samba-credenciais
   # Dentro do arquivo:
   username=aluno
   password=suasenha
       

   Proteja o arquivo:

   sudo chmod 600 /etc/samba-credenciais

3. Adicione a linha ao /etc/fstab:

   
   //192.168.1.10/publico   /mnt/publico   cifs   credentials=/etc/samba-credenciais,iocharset=utf8,uid=1000,gid=1000  0  0
       

   • Substitua 192.168.1.10, publico e os IDs de usuário (uid, gid) conforme seu ambiente.
4. Monte tudo:

   sudo mount -a

Agora o compartilhamento será montado automaticamente ao iniciar o sistema.

💾 Script de backup de pasta Samba

#!/bin/bash
# Backup diário de /mnt/publico para /home/$USER/backup_samba/
ORIGEM="/mnt/publico"
DESTINO="/home/$USER/backup_samba/$(date +%F)"
mkdir -p "$DESTINO"
rsync -avh --delete "$ORIGEM/" "$DESTINO/"
echo "Backup concluído: $DESTINO"
  

Programe esse script no cron para execução diária, semanal, etc. Dica: O parâmetro --delete sincroniza apagando arquivos removidos na origem.

🏢 Samba + Active Directory (AD)

O Samba pode ser integrado a domínios Active Directory para autenticação centralizada, mapeamento de permissões e gerenciamento empresarial.

• Samba como membro de domínio:
  • Permite que servidores Samba autentiquem usuários via AD, usando winbind.
  • Edite /etc/samba/smb.conf com:

    
    [global]
       workgroup = DOMINIO
       security = ADS
       realm = DOMINIO.EXEMPLO.COM.BR
       winbind use default domain = yes
            

  • Instale e configure krb5-user (Kerberos) e winbind:

    sudo apt install winbind krb5-user

  • Utilize net ads join para ingressar no domínio:

  sudo net ads join -U administrador

  • Reinicie serviços:

    sudo systemctl restart smbd nmbd winbind

  • Agora, permissões dos compartilhamentos podem ser baseadas em grupos e usuários do AD.
• Samba como controlador de domínio AD:
  • O Samba 4 pode atuar como controlador de domínio AD, substituindo Windows Server AD.
  • Processo é mais complexo (use este guia oficial).

Observação: Integração com AD é tema avançado e pode envolver ajustes finos em DNS, Kerberos, políticas de grupo e scripts de logon.

🔐 Autenticação de Usuários Linux no Active Directory

É possível autenticar logins do Linux diretamente contra o AD, permitindo que usuários usem as mesmas credenciais do domínio para acessar o sistema e compartilhamentos Samba.
Esse recurso é muito usado em empresas que querem padronizar senhas e permissões.

1. Instale os pacotes necessários:

   sudo apt install realmd sssd sssd-tools libnss-sss libpam-sss adcli samba-common-bin packagekit

2. Descubra o domínio:

   realm discover DOMINIO.EXEMPLO.COM.BR

3. Junte-se ao domínio:

   sudo realm join --user=administrador DOMINIO.EXEMPLO.COM.BR

   • Substitua administrador pelo nome de um usuário AD com permissão para adicionar máquinas ao domínio.
   • Você será solicitado a informar a senha do administrador do domínio.
4. Teste a autenticação:

   id usuario@DOMINIO.EXEMPLO.COM.BR

   Se aparecer UID/GID do usuário, a autenticação está funcionando!

5. Faça login como usuário do domínio:

   su - usuario@DOMINIO.EXEMPLO.COM.BR

   Ou faça logout da sessão gráfica e tente logar usando as credenciais do domínio.

6. Verifique usuários e grupos do AD:

   getent passwd
   getent group
   wbinfo -u     # Lista usuários AD
   wbinfo -g     # Lista grupos AD
   

Dicas:

• O login pode exigir o formato completo usuario@DOMINIO na tela de login do Linux.
• Configure /etc/sssd/sssd.conf para ajustar cache, mapeamento de home e permissões (o arquivo exige permissão 600).
• No Samba, adicione winbind use default domain = yes para facilitar login sem o sufixo de domínio (opcional).
• Usuários autenticados via AD podem acessar compartilhamentos Samba protegidos e outros serviços (SSH, sudo, etc), conforme políticas definidas no domínio.

Referências oficiais: Debian: Authenticating Linux With Active Directory | Samba Wiki: Idmap config ad

Firewall Avançado e Segurança

Garantir a segurança de um sistema GNU/Linux envolve controlar acessos de rede, monitorar tentativas de ataque e proteger serviços críticos. Firewalls filtram conexões indesejadas, enquanto boas práticas de segurança e ferramentas complementares aumentam a proteção.

🔥 UFW – Firewall Simples

• UFW (Uncomplicated Firewall) facilita o uso do iptables com comandos simples:

sudo ufw enable                 # Ativa o firewall
sudo ufw status                 # Mostra regras ativas
sudo ufw allow 22/tcp           # Libera SSH (porta 22)
sudo ufw allow 80,443/tcp       # Libera HTTP e HTTPS
sudo ufw deny 23                # Bloqueia Telnet (exemplo)

• Para resetar ou desabilitar:

sudo ufw reset
sudo ufw disable

🛡️ IPTABLES – Controle Avançado de Pacotes

• Permite criar regras detalhadas para filtragem de tráfego:

# Permite conexões SSH
sudo iptables -A INPUT -p tcp --dport 22 -j ACCEPT
# Permite conexões HTTP/HTTPS
sudo iptables -A INPUT -p tcp -m multiport --dports 80,443 -j ACCEPT
# Bloqueia tudo o resto (depois das regras de permissão)
sudo iptables -P INPUT DROP
# Salva as regras (varia por distro)
sudo iptables-save | sudo tee /etc/iptables/rules.v4
    

• Para listar regras:

sudo iptables -L -n -v

• OBS: Mudanças feitas com iptables afetam imediatamente o tráfego de rede!

🚦 FIREWALLD – Gerenciamento Dinâmico

• Usado em sistemas Red Hat, Fedora, CentOS, permite mudanças de regras em tempo real com zonas de confiança:

sudo systemctl start firewalld         # Inicia serviço
sudo firewall-cmd --state              # Verifica status
sudo firewall-cmd --list-all           # Lista regras da zona padrão
sudo firewall-cmd --add-service=ssh --permanent
sudo firewall-cmd --reload             # Aplica mudanças
    

• Use firewall-config para interface gráfica.

🛑 Fail2Ban – Proteção contra Ataques de Força Bruta

• Fail2Ban monitora logs (ex: SSH) e bloqueia IPs que tentam acessos inválidos repetidos:

  sudo apt install fail2ban
  sudo systemctl enable --now fail2ban
  # Editar jail:
  sudo nano /etc/fail2ban/jail.local
  # Ative e configure [sshd] para proteger o SSH

• Logs e ações podem ser monitorados em /var/log/fail2ban.log.

🔒 SSH Hardening & Chaves

• Use autenticação por chaves para SSH:

  ssh-keygen                          # Gera chave no cliente
  ssh-copy-id usuario@servidor        # Copia chave pública
        

• Outras recomendações:
  • Desabilite login root remoto: PermitRootLogin no em /etc/ssh/sshd_config
  • Troque a porta padrão 22 por outra
  • Use AllowUsers para restringir usuários permitidos
  • Reinicie SSH após alterar configs: sudo systemctl restart ssh

🔎 Identificando portas abertas e escaneamento

• ss e netstat mostram conexões e portas abertas localmente:

  ss -tuln           # Lista portas TCP/UDP abertas
  netstat -tuln      # (instale o pacote net-tools)
  lsof -i            # Mostra processos e conexões
        

• nmap escaneia portas de hosts remotos (ou do próprio):

  sudo apt install nmap
  nmap localhost              # Escaneia portas locais
  nmap 192.168.1.10           # Escaneia máquina remota
  nmap -p 1-65535 servidor    # Escaneia todas as portas

📚 Exercícios práticos

1. Ative e configure o UFW, libere só SSH e HTTP, bloqueie tudo o resto. Tente acessar via outra porta e veja o resultado.
2. Crie regras personalizadas no iptables para bloquear tentativas de ping (ICMP).
3. Instale e teste o Fail2Ban: faça várias tentativas erradas de login SSH e veja seu IP ser bloqueado.
4. Configure o SSH para aceitar apenas chaves e negue o root. Tente acessar com senha e veja a recusa.
5. Use nmap para escanear sua própria máquina e identificar portas abertas. Compare com a saída do ss/netstat.

Um bom firewall, somado a práticas de segurança como Fail2Ban e SSH fortalecido, são essenciais para proteger sistemas Linux, seja em servidores, desktops ou nuvem!

Virtualização Completa (KVM, VirtualBox)

Virtualização completa permite executar múltiplos sistemas operacionais simultaneamente, cada um em uma "máquina virtual" isolada, utilizando todo o hardware disponível do host. É muito usada em testes, laboratórios, servidores e ambientes de produção.

⚡ Diferença entre Virtualização Completa e Containers

• Virtualização Completa (KVM, VirtualBox, VMware, Hyper-V):
  • Simula hardware completo para cada VM.
  • Cada VM tem seu próprio kernel e sistema operacional.
  • Isolamento total; ideal para rodar Windows, Linux, BSD, etc. em paralelo.
  • Consome mais recursos, mas oferece máxima flexibilidade e segurança.
• Containers (Docker, Podman, LXC):
  • Compartilham o kernel do host.
  • Isolam processos e dependências, mas rodam apenas sistemas compatíveis com o kernel do host.
  • Mais leves e rápidos; ideais para microserviços, CI/CD, testes rápidos.

💻 KVM/QEMU: Virtualização nativa no Linux

• KVM (Kernel-based Virtual Machine) é o padrão em Linux para virtualização acelerada por hardware (Intel VT-x, AMD-V).
• Para usar, instale:

  sudo apt install qemu-kvm libvirt-daemon-system libvirt-clients bridge-utils virt-manager

• virt-manager: Interface gráfica para criar, configurar e gerenciar VMs facilmente.
  • Abra com: virt-manager
  • Permite snapshots, ajuste de CPU/RAM/discos, rede, etc.
• virsh: Interface de linha de comando para automação e scripts.

  sudo virsh list --all           # Lista VMs
  sudo virsh start nome_da_vm     # Inicia VM
  sudo virsh shutdown nome_da_vm  # Desliga VM
  sudo virsh suspend nome_da_vm   # Suspende
  sudo virsh resume nome_da_vm    # Retoma
  sudo virsh destroy nome_da_vm   # Força desligamento
  sudo virsh snapshot-list nome_da_vm    # Lista snapshots
        

  • Para criar VMs por CLI: virt-install
• Verificando suporte do hardware:

  egrep -c '(vmx|svm)' /proc/cpuinfo

  Se retornar 1 ou mais, sua CPU suporta virtualização nativa.

🖥️ VirtualBox

• VirtualBox é multiplataforma, fácil de instalar e usar:

  sudo apt install virtualbox

  • Crie VMs via interface gráfica ou linha de comando (VBoxManage).
  • Permite snapshots, compartilhamento de pastas, integração com o desktop, etc.
• Principais comandos VBoxManage:

  VBoxManage list vms               # Lista VMs
  VBoxManage startvm "NomeVM"       # Inicia VM
  VBoxManage controlvm "NomeVM" poweroff   # Força desligamento
        

📚 Exercícios práticos

1. Instale o virt-manager, crie uma VM Linux, ajuste CPUs/RAM e instale o sistema operacional convidado.
2. Gerencie VMs usando virsh: inicie, pare, crie snapshot e restaure.
3. Instale o VirtualBox e crie uma VM para testar um sistema diferente do seu (ex: BSD, Windows).
4. Compare consumo de recursos entre VMs e containers rodando o mesmo serviço.
5. Desafie-se: configure rede em bridge para a VM acessar a rede real do host.

Virtualização completa permite criar ambientes isolados, seguros e realistas para estudo, desenvolvimento, testes e produção!

Containers (Docker/Podman)

Containers são tecnologias que permitem empacotar, distribuir e executar aplicações de forma isolada, leve e eficiente, compartilhando o kernel do sistema host mas isolando processos, redes e sistemas de arquivos. As ferramentas mais usadas atualmente são Docker e Podman.

🚀 O que é um container?

• É uma "caixa" leve que contém uma aplicação e todas as suas dependências.
• Diferente de uma máquina virtual, containers não simulam hardware — compartilham o kernel do host, mas cada container é isolado dos demais.
• Iniciam e param rapidamente, consomem menos recursos e são ideais para ambientes de testes, desenvolvimento, produção e microserviços.

🐳 Docker: principais comandos

# Verifique se o Docker está instalado e rodando
sudo systemctl status docker

# Baixe e rode um container interativo
docker run -it ubuntu bash

# Liste containers em execução
docker ps

# Liste todos os containers (inclusive parados)
docker ps -a

# Execute comando em container rodando (exemplo: abrir bash)
docker exec -it  bash

# Pare e remova containers
docker stop 
docker rm 

# Remova imagens não utilizadas
docker image prune -a

# Liste imagens disponíveis localmente
docker images
  

🧑‍💻 Quando usar containers?

• Para ambientes de desenvolvimento: cada dev roda a mesma aplicação em container, evitando problemas de "funciona na minha máquina".
• Para testes automatizados: pipelines CI/CD criam containers, executam testes e descartam rapidamente.
• Para microserviços: cada serviço (API, banco de dados, frontend, etc.) roda isolado em seu próprio container.
• Para implementar aplicações em produção: orquestração com Kubernetes, Swarm, etc.

📝 Exemplos de uso prático

• Subir um servidor web NGINX em container:

  docker run -d --name meu-nginx -p 8080:80 nginx

  Agora acesse localhost:8080 no navegador.

• Executar um container de Python e rodar scripts:

  docker run -it --rm python:3.11 bash
  # Dentro do container:
  python

• Salvar mudanças de um container como nova imagem:

  docker commit  minha-imagem:1.0

• Docker Compose (multi-containers): Exemplo de arquivo docker-compose.yml:

  version: '3'
  services:
    web:
      image: nginx
      ports:
        - "8080:80"
    db:
      image: mysql
      environment:
        MYSQL_ROOT_PASSWORD: exemplo123
  

  docker compose up -d
  docker compose down
  

🍀 Podman: alternativa rootless ao Docker

• Podman é compatível com Docker, mas roda sem daemon central e pode ser usado por usuários não-root.
• Principais comandos são quase idênticos:

podman run -it ubuntu bash
podman ps
podman images
podman stop 
    

• Para usar Podman no lugar do Docker, basta trocar o comando.

📚 Exercícios práticos

1. Rode um container Ubuntu, instale e execute um programa básico dentro dele.
2. Crie um arquivo docker-compose.yml com um serviço web e um banco de dados, suba ambos e teste a comunicação.
3. Liste todos os containers rodando e pare-os.
4. Compare o tempo de inicialização de um container vs. uma VM.
5. Desafie-se: use Podman para rodar o mesmo serviço sem privilégios de root.

Containers revolucionaram o desenvolvimento, tornando ambientes portáteis, reproduzíveis e escaláveis. Aprender Docker ou Podman é essencial para qualquer profissional de TI moderno!

🛠️ Construindo suas próprias imagens com Dockerfile

• Um Dockerfile é um arquivo de texto que descreve passo a passo como montar uma imagem personalizada.

  # Exemplo: Dockerfile para um app Python
  FROM python:3.11
  WORKDIR /app
  COPY . .
  RUN pip install -r requirements.txt
  CMD ["python", "meu_script.py"]
      

  • Crie o arquivo Dockerfile na raiz do projeto.
  • Construa a imagem com:

    docker build -t meu-app:1.0 .

  • Rode o container:

    docker run meu-app:1.0

📤 Publicando imagens no DockerHub (push/pull)

• Crie uma conta gratuita em hub.docker.com.
• Faça login no terminal:

  docker login

• Marque sua imagem com seu usuário:

  docker tag meu-app:1.0 seu_usuario/meu-app:1.0

• Envie (push) a imagem:

  docker push seu_usuario/meu-app:1.0

• Para baixar (pull) em outro sistema:

  docker pull seu_usuario/meu-app:1.0

☸️ Orquestração: Docker + Kubernetes (K8s)

• Kubernetes é o orquestrador mais usado para gerenciar centenas de containers em clusters.
  • Arquivo de exemplo pod.yaml para rodar um container Nginx:

    apiVersion: v1
    kind: Pod
    metadata:
      name: meu-nginx
    spec:
      containers:
        - name: nginx
          image: nginx
          ports:
            - containerPort: 80
            

    kubectl apply -f pod.yaml   # Cria o pod
    kubectl get pods            # Lista pods rodando
            

  • Para testar localmente, use o Minikube ou kind.
  • Aprender Kubernetes é o próximo passo após dominar Docker!

Quiz Interativo

Teste seus conhecimentos sobre GNU/Linux: