DevOps Bootcamp · Aula

Automação de discos, sistemas de arquivos e montagem

Inspecione dispositivos de bloco, gerencie entradas do fstab e automatize operações do LVM e de montagem com segurança.

Automação de discos, sistemas de arquivos e montagem é uma aula grátis de DevOps Bootcamp no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de DevOps Bootcamp, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de DevOps Bootcamp inclui 4 aulas no total.

Entendendo dispositivos de bloco com lsblk e fdisk

Antes de automatizar operações de disco, você precisa ser capaz de inspecionar quais dispositivos de bloco existem no sistema. Duas ferramentas essenciais são lsblk e fdisk -l.

lsblk — lista dispositivos de bloco em formato de árvore, mostrando nomes de dispositivos, tamanhos, pontos de montagem e tipos (disk, part, lvm)
fdisk -l — mostra tabelas de partição e detalhes dos setores (requer root)
blkid — exibe os UUIDs e os tipos de sistema de arquivos de cada dispositivo de bloco

Em scripts, frequentemente será necessário analisar essa saída para detectar discos disponíveis, verificar se uma partição está formatada ou determinar seu UUID antes de montá-la.

#!/usr/bin/env bash
# Inspect all block devices and their UUIDs
set -euo pipefail

echo '=== Block Device Tree ==='
lsblk -o NAME,SIZE,TYPE,FSTYPE,MOUNTPOINT,UUID

echo ''
echo '=== Partition Table Details ==='
sudo fdisk -l 2>/dev/null | grep -E '^Disk |^/dev/'

echo ''
echo '=== UUID Lookup via blkid ==='
sudo blkid | awk -F: '{print $1}' | while read -r dev; do
  uuid=$(sudo blkid -s UUID -o value "$dev" 2>/dev/null || echo 'N/A')
  fstype=$(sudo blkid -s TYPE -o value "$dev" 2>/dev/null || echo 'unknown')
  printf '%-20s UUID=%-38s TYPE=%s\n' "$dev" "$uuid" "$fstype"
done

Verificando o espaço em disco com df e du

df e du são as principais ferramentas para informar o uso de sistemas de arquivos e diretórios. Em scripts de administração de sistemas, você as utiliza para disparar alertas, aplicar cotas ou decidir quando provisionar mais espaço.

df -h — uso dos sistemas de arquivos em formato legível por humanos em todos os sistemas de arquivos montados
df -BG — saída em gigabytes para uma análise numérica consistente
du -sh /path — tamanho resumido de um diretório específico
du -d 1 /var — detalhamento com um nível de profundidade (útil para descobrir qual subdiretório é grande)

A coluna de porcentagem usada de df é frequentemente analisada para disparar alertas de disco cheio em scripts de monitoramento.

#!/usr/bin/env bash
# Alert if any mounted filesystem exceeds a usage threshold
set -euo pipefail

THRESHOLD=80   # percent

echo 'Checking filesystem usage...'
df -h --output=source,pcent,target | tail -n +2 | while IFS= read -r line; do
  device=$(awk '{print $1}' <<< "$line")
  pct=$(awk '{print $2}' <<< "$line" | tr -d '%')
  mount=$(awk '{print $3}' <<< "$line")

  # Skip pseudo filesystems
  [[ "$device" == tmpfs* || "$device" == devtmpfs* ]] && continue

  if (( pct >= THRESHOLD )); then
    echo "WARNING: $device mounted at $mount is ${pct}% full" >&2
  else
    echo "OK: $device at $mount is ${pct}% used"
  fi
done

Lendo e analisando /etc/fstab

/etc/fstab é a tabela estática de sistemas de arquivos — ela define quais dispositivos serão montados na inicialização, em qual caminho e com quais opções. Cada linha possui seis campos:

Dispositivo — UUID=..., LABEL=... ou /dev/sdX
Ponto de montagem — caminho do diretório
Tipo de sistema de arquivos — ext4, xfs, nfs, tmpfs etc.
Opções — defaults, ro, noexec, nofail etc.
Dump — 0 ou 1 (indicador de backup)
Pass — 0, 1 ou 2 (ordem do fsck)

Os scripts que adicionam ou validam entradas do fstab devem lidar corretamente com comentários (linhas que começam com #) e linhas em branco. Prefira sempre UUID aos nomes de dispositivos para resistir a reinicializações nas quais a ordem dos dispositivos possa mudar.

#!/usr/bin/env bash
# Parse /etc/fstab and display non-comment entries in a readable table
set -euo pipefail

FSTAB=/etc/fstab

printf '%-40s %-20s %-10s %s\n' 'DEVICE' 'MOUNTPOINT' 'FSTYPE' 'OPTIONS'
printf '%s\n' '-------------------------------------------------------------------------------------'

while IFS= read -r line; do
  # Skip blank lines and comments
  [[ -z "$line" || "$line" =~ ^[[:space:]]*# ]] && continue

  read -r device mountpt fstype options _dump _pass <<< "$line"
  printf '%-40s %-20s %-10s %s\n' "$device" "$mountpt" "$fstype" "$options"
done < "$FSTAB"

Adicionando uma entrada do fstab com segurança

Editar /etc/fstab manualmente é propenso a erros. Uma entrada incorreta pode impedir a inicialização do sistema. Um script de automação seguro deve:

Verificar se a entrada já existe antes de adicioná-la (idempotência)
Fazer backup do arquivo original antes de qualquer modificação
Usar UUID em vez do caminho do dispositivo
Adicionar nofail às opções de montagem para que a ausência de um disco não interrompa a inicialização
Executar mount -a em modo de simulação ou fazer uma montagem de teste para validar antes de reiniciar

Depois de gravar a entrada, sempre faça a verificação com findmnt --verify (disponível em distribuições modernas com systemd) para detectar imediatamente erros de sintaxe.

#!/usr/bin/env bash
# Safely append a new entry to /etc/fstab (idempotent)
set -euo pipefail

DEVICE_PATH='/dev/sdb1'
MOUNTPOINT='/mnt/data'
FSTYPE='ext4'
OPTIONS='defaults,nofail'
FSTAB='/etc/fstab'

# Resolve UUID for stable identification
UUID=$(sudo blkid -s UUID -o value "$DEVICE_PATH")
if [[ -z "$UUID" ]]; then
  echo "ERROR: Could not resolve UUID for $DEVICE_PATH" >&2
  exit 1
fi

ENTRY="UUID=$UUID  $MOUNTPOINT  $FSTYPE  $OPTIONS  0  2"

# Idempotency: skip if UUID already referenced in fstab
if grep -qsF "UUID=$UUID" "$FSTAB"; then
  echo "INFO: fstab already contains UUID=$UUID — skipping."
  exit 0
fi

# Backup
cp -p "$FSTAB" "${FSTAB}.bak.$(date +%Y%m%d%H%M%S)"

# Create mountpoint if needed
sudo mkdir -p "$MOUNTPOINT"

# Append entry
echo "$ENTRY" | sudo tee -a "$FSTAB" > /dev/null
echo "INFO: Added: $ENTRY"

# Validate
sudo findmnt --verify --verbose || echo 'WARNING: findmnt verify reported issues'

Montando e desmontando sistemas de arquivos em scripts

Os comandos mount e umount são simples, mas os scripts precisam tratar casos extremos:

Um dispositivo pode já estar montado — montá-lo novamente falha; verifique com findmnt ou mountpoint
Um ponto de montagem pode estar ocupado (há arquivos abertos) — umount falha; use lsof +D /mnt/target para encontrar os processos responsáveis
Use mount -o remount,ro /mnt/data para mudar para somente leitura sem desmontar
Use umount -l /mnt/data (desmontagem preguiçosa) como último recurso — ele desanexa o espaço de nomes, mas aguarda o fechamento das referências

Na automação, sempre verifique o código de saída de mount e registre as falhas no syslog com logger.

#!/usr/bin/env bash
# Mount a device only if not already mounted; log outcome
set -euo pipefail

DEVICE='/dev/sdb1'
MOUNTPOINT='/mnt/data'

log() { logger -t disk-mount "$*"; echo "[$(date '+%F %T')] $*"; }

# Check if already mounted
if mountpoint -q "$MOUNTPOINT"; then
  log "INFO: $MOUNTPOINT is already mounted — nothing to do."
  exit 0
fi

# Ensure mountpoint directory exists
sudo mkdir -p "$MOUNTPOINT"

# Attempt mount
if sudo mount "$DEVICE" "$MOUNTPOINT"; then
  log "OK: Mounted $DEVICE at $MOUNTPOINT"
else
  log "ERROR: Failed to mount $DEVICE at $MOUNTPOINT"
  exit 1
fi

# Show what is now mounted there
df -h "$MOUNTPOINT"

Introdução ao LVM: volumes físicos, grupos de volumes e volumes lógicos

LVM (Gerenciador de Volumes Lógicos) adiciona uma camada de abstração flexível entre dispositivos de bloco brutos e sistemas de arquivos. A hierarquia de três níveis é:

Volume Físico (PV) — um disco ou partição bruta inicializada com pvcreate
Grupo de Volumes (VG) — um ou mais PVs reunidos em um conjunto com vgcreate
Volume Lógico (LV) — uma partição virtual criada a partir de um VG com lvcreate; é isso que você formata e monta

A principal vantagem é poder estender um LV online sem desmontá-lo e adicionar novos discos a um VG sem formatá-lo novamente. Isso torna o LVM essencial para a automação do armazenamento em produção.

Comandos de inspeção: pvs, vgs, lvs e suas versões detalhadas pvdisplay, vgdisplay, lvdisplay.

Criando volumes LVM com scripts

A automatização da configuração do LVM segue uma sequência rigorosa: pvcreate → vgcreate → lvcreate → mkfs → mount. Cada etapa deve ser concluída com sucesso antes da execução da próxima — use set -euo pipefail e valide a saída de cada comando.

Sempre verifique se o disco de destino não tem uma tabela de partições existente antes de chamar pvcreate
Use a opção -y para suprimir solicitações interativas em scripts não interativos
Especifique -L (tamanho fixo) ou -l 100%FREE para usar todo o espaço restante
Depois de mkfs, use o caminho do dispositivo do LV: /dev/<vgname>/<lvname>

#!/usr/bin/env bash
# Automate LVM setup: PV -> VG -> LV -> mkfs -> mount
set -euo pipefail

DISK='/dev/sdc'          # raw disk, no existing partitions
VG_NAME='vg_appdata'
LV_NAME='lv_appdata'
LV_SIZE='10G'
MOUNTPOINT='/mnt/appdata'
FSTYPE='xfs'

echo "[1/6] Initializing Physical Volume on $DISK"
sudo pvcreate -y "$DISK"

echo "[2/6] Creating Volume Group: $VG_NAME"
sudo vgcreate "$VG_NAME" "$DISK"

echo "[3/6] Creating Logical Volume: $LV_NAME (${LV_SIZE})"
sudo lvcreate -y -L "$LV_SIZE" -n "$LV_NAME" "$VG_NAME"

echo "[4/6] Formatting as $FSTYPE"
sudo mkfs."$FSTYPE" "/dev/$VG_NAME/$LV_NAME"

echo "[5/6] Mounting at $MOUNTPOINT"
sudo mkdir -p "$MOUNTPOINT"
sudo mount "/dev/$VG_NAME/$LV_NAME" "$MOUNTPOINT"

echo "[6/6] Done. Disk usage:"
df -h "$MOUNTPOINT"

# Show LVM summary
vgs && lvs

Estendendo um volume lógico online

Um dos recursos mais poderosos do LVM é o redimensionamento online — estender um volume lógico e seu sistema de arquivos enquanto ele está montado e em uso. O procedimento é:

Estenda o LV com lvextend (a opção -r redimensiona o sistema de arquivos na mesma etapa)
Se não usar -r, redimensione o sistema de arquivos separadamente: resize2fs para ext4, xfs_growfs para xfs

Restrições importantes:

xfs só pode crescer, nunca diminuir — planeje a capacidade com cuidado
ext4 pode diminuir, mas somente enquanto estiver desmontado
Sempre verifique se o VG tem espaço livre com vgdisplay -s antes de estender

#!/usr/bin/env bash
# Extend an LV and its xfs filesystem online
set -euo pipefail

VG_NAME='vg_appdata'
LV_NAME='lv_appdata'
EXTEND_BY='5G'
LV_DEV="/dev/$VG_NAME/$LV_NAME"

# Confirm VG has enough free space
FREE_GB=$(vgs --noheadings --units g -o vg_free "$VG_NAME" | tr -d ' g')
echo "VG free space: ${FREE_GB}G"
if (( $(echo "$FREE_GB < 5" | bc -l) )); then
  echo 'ERROR: Not enough free space in VG' >&2
  exit 1
fi

echo "Extending LV by $EXTEND_BY..."
sudo lvextend -L "+${EXTEND_BY}" "$LV_DEV"

echo 'Growing xfs filesystem online...'
sudo xfs_growfs "$LV_DEV"

echo 'New size:'
df -h "$LV_DEV"
lvs "$LV_DEV"

Criando e formatando sistemas de arquivos

Depois de particionar ou configurar o LVM, é necessário formatar o dispositivo de bloco com um sistema de arquivos. Opções comuns na administração do Linux:

ext4 — maduro, com registro de alterações, compatível com redução; padrão em muitas distribuições (mkfs.ext4)
xfs — alto desempenho, preferido para arquivos grandes e E/S paralela; padrão no RHEL/CentOS (mkfs.xfs)
btrfs — cópia na gravação, com instantâneos integrados (mkfs.btrfs)
tmpfs — respaldado por RAM, especificado no fstab sem mkfs

Sempre defina um rótulo significativo para o sistema de arquivos (opção -L) para que o dispositivo possa ser referenciado por LABEL= no fstab como alternativa ao UUID.

#!/usr/bin/env bash
# Format a partition and assign a label; print resulting UUID
set -euo pipefail

PARTITION='/dev/sdb1'
FSTYPE='ext4'
LABEL='appdata'

# Safety check: refuse to format a currently mounted device
if findmnt --source "$PARTITION" > /dev/null 2>&1; then
  echo "ERROR: $PARTITION is currently mounted. Unmount first." >&2
  exit 1
fi

echo "Formatting $PARTITION as $FSTYPE with label '$LABEL'..."
sudo mkfs."$FSTYPE" -L "$LABEL" -F "$PARTITION"

# Retrieve and display the new UUID
NEW_UUID=$(sudo blkid -s UUID -o value "$PARTITION")
echo "Formatted successfully."
echo "Label : $LABEL"
echo "UUID  : $NEW_UUID"
echo "Use this in fstab: UUID=$NEW_UUID  /mnt/$LABEL  $FSTYPE  defaults,nofail  0  2"

Automatizando montagens NFS com autofs

Para sistemas de arquivos de rede, montar durante a inicialização com fstab pode causar atrasos ou falhas se o servidor NFS estiver temporariamente inacessível. O autofs resolve esse problema montando sob demanda e desmontando após um tempo limite.

Mapa principal: /etc/auto.master — define o diretório do ponto de montagem e seu arquivo de mapa
Mapa direto: /etc/auto.nfs — especifica as opções e o caminho do servidor NFS para cada subdiretório
Recarregue com systemctl reload autofs após as alterações
As montagens aparecem automaticamente no diretório configurado quando são acessadas

Nos scripts, você pode gerar dinamicamente o arquivo de mapa a partir de uma lista de compartilhamentos NFS e recarregar o autofs — isso é útil para provisionar armazenamento compartilhado em muitos hosts.

#!/usr/bin/env bash
# Generate an autofs NFS map file from a share list and reload autofs
set -euo pipefail

NFS_SERVER='192.168.1.50'
AUTO_MAP='/etc/auto.nfs'
AUTO_MASTER='/etc/auto.master'
MOUNT_BASE='/nfs'

# Define shares: localname:remote_path
declare -A SHARES=(
  [homes]='/export/homes'
  [media]='/export/media'
  [backups]='/export/backups'
)

# Write map file
{
  echo '# Generated by disk-automation script'
  for localname in "${!SHARES[@]}"; do
    remote="${SHARES[$localname]}"
    echo "$localname  -rw,soft,timeo=30  ${NFS_SERVER}:${remote}"
  done
} | sudo tee "$AUTO_MAP" > /dev/null

echo "Wrote $AUTO_MAP"

# Ensure master map references this file
if ! grep -qF "$AUTO_MAP" "$AUTO_MASTER"; then
  echo "$MOUNT_BASE  $AUTO_MAP" | sudo tee -a "$AUTO_MASTER" > /dev/null
  echo "Updated $AUTO_MASTER"
fi

sudo systemctl reload autofs && echo 'autofs reloaded'

Instantâneo LVM para backups seguros

Os instantâneos do LVM fornecem uma cópia de um volume lógico em um determinado momento, permitindo fazer backups consistentes de sistemas de arquivos ativos sem desmontá-los. O instantâneo captura o estado no momento da criação usando cópia na gravação.

Criar: lvcreate -s -n lv_snap -L 2G /dev/vg_data/lv_data
Monte o instantâneo como somente leitura para fazer o backup: mount -o ro /dev/vg_data/lv_snap /mnt/snap
Execute rsync ou tar no ponto de montagem do instantâneo
Remova o instantâneo após o backup: umount /mnt/snap && lvremove -f /dev/vg_data/lv_snap

Mantenha o tamanho do instantâneo em 10–20% do LV de origem. Se o instantâneo ficar cheio, ele se tornará inválido — monitore com lvs -o lv_name,snap_percent.

#!/usr/bin/env bash
# Create an LVM snapshot, back up via tar, then remove snapshot
set -euo pipefail

VG='vg_appdata'
ORIGIN_LV='lv_appdata'
SNAP_LV='lv_appdata_snap'
SNAP_SIZE='2G'
SNAP_MOUNT='/mnt/snap_backup'
BACKUP_DEST='/var/backups/appdata'
DATESTAMP=$(date +%Y%m%d_%H%M%S)

trap 'sudo umount "$SNAP_MOUNT" 2>/dev/null; sudo lvremove -f "/dev/$VG/$SNAP_LV" 2>/dev/null' ERR EXIT

echo '[1] Creating snapshot...'
sudo lvcreate -s -n "$SNAP_LV" -L "$SNAP_SIZE" "/dev/$VG/$ORIGIN_LV"

echo '[2] Mounting snapshot read-only...'
sudo mkdir -p "$SNAP_MOUNT"
sudo mount -o ro "/dev/$VG/$SNAP_LV" "$SNAP_MOUNT"

echo '[3] Archiving to backup destination...'
sudo mkdir -p "$BACKUP_DEST"
sudo tar -czf "$BACKUP_DEST/appdata_${DATESTAMP}.tar.gz" -C "$SNAP_MOUNT" .

echo '[4] Cleaning up snapshot...'
sudo umount "$SNAP_MOUNT"
sudo lvremove -f "/dev/$VG/$SNAP_LV"

echo "Backup complete: $BACKUP_DEST/appdata_${DATESTAMP}.tar.gz"

Verificação de conhecimentos: automação segura do fstab e das montagens

Teste sua compreensão das práticas seguras de automação de discos, sistemas de arquivos e montagens abordadas nesta lição.

Recapitulação da lição: automação de discos, sistemas de arquivos e montagens

Nesta lição, você criou um conjunto completo de ferramentas para o gerenciamento seguro e automatizável de discos e armazenamento em sistemas Linux. Principais pontos:

Inspeção primeiro: lsblk, blkid, df e du fornecem as informações necessárias antes de qualquer alteração.
Disciplina com o fstab: use sempre UUID, inclua sempre nofail, faça sempre um backup antes de editar e valide com findmnt --verify.
Segurança nas montagens: verifique mountpoint -q antes de montar, registre com logger e trate erros de dispositivos ocupados com lsof.
Poder do LVM: o fluxo PV → VG → LV permite extensões online e backups baseados em instantâneos sem indisponibilidade.
A escolha do sistema de arquivos é importante: xfs para desempenho (somente crescimento), ext4 para flexibilidade (pode diminuir offline), btrfs para cargas de trabalho nativas de instantâneos.
NFS sob demanda: o autofs evita atrasos na inicialização ao montar compartilhamentos de rede somente quando são acessados.
Backups com instantâneos: os instantâneos do LVM fornecem backups consistentes e ativos — mas monitore sempre snap_percent e remova os instantâneos imediatamente após o backup.

Combine esses padrões para automatizar de forma confiável todo o ciclo de vida do armazenamento: descoberta, provisionamento, montagem, redimensionamento e backup.

Perguntas Frequentes

A aula “Automação de discos, sistemas de arquivos e montagem” é grátis?

Sim — o texto completo de “Automação de discos, sistemas de arquivos e montagem” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de DevOps Bootcamp, atualize para CoddyKit PRO. O curso de DevOps Bootcamp inclui 4 aulas no total.

O que vou aprender em “Automação de discos, sistemas de arquivos e montagem”?

Inspecione dispositivos de bloco, gerencie entradas do fstab e automatize operações do LVM e de montagem com segurança. Você pratica DevOps Bootcamp com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar DevOps Bootcamp?

Nenhuma experiência prévia é necessária. DevOps Bootcamp no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.

Quanto tempo leva a aula “Automação de discos, sistemas de arquivos e montagem”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de DevOps Bootcamp?

Sim. Cada aula de DevOps Bootcamp inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

Automação do provisionamento de usuários e grupos
Controle de serviços do systemd e criação de arquivos de unidade
Automação de discos, sistemas de arquivos e montagem
Criação de scripts de verificação e alerta da integridade do sistema

← Voltar para DevOps Bootcamp