TL;DR — Resumo Rápido

Particionamento de disco Linux com fdisk e parted: crie tabelas MBR e GPT, formate sistemas de arquivos e monte persistentemente com UUID no /etc/fstab.

O particionamento de disco Linux é uma habilidade fundamental para qualquer sysadmin ou engenheiro DevOps. Seja para adicionar um disco de dados a um servidor, configurar uma nova instalação ou preparar armazenamento para um banco de dados, entender como particionar discos com fdisk e parted — e como persistir montagens no /etc/fstab usando UUIDs — vai salvar você de erros custosos e tempo de inatividade. Este guia cobre o fluxo de trabalho completo, do disco bruto ao sistema de arquivos montado e com automontagem.

Pré-requisitos

  • Acesso root ou sudo em um sistema Linux
  • Um disco bruto ou disco virtual conectado à máquina (por exemplo, /dev/sdb)
  • Familiaridade básica com o terminal Linux
  • Pacote util-linux instalado (fornece fdisk, lsblk, blkid — presente por padrão na maioria das distros)
  • parted instalado: apt install parted ou dnf install parted

MBR vs GPT: Escolhendo a Tabela de Partições Correta

Antes de tocar em um disco, você precisa decidir qual formato de tabela de partições usar. Os dois padrões são MBR (Master Boot Record) e GPT (GUID Partition Table).

Recurso MBR GPT
Tamanho máximo do disco 2 TB 9,4 ZB (efetivamente ilimitado)
Máximo de partições primárias 4 (ou 3 primárias + estendida) 128
Firmware de boot BIOS UEFI (também funciona com BIOS via híbrido)
Redundância Nenhuma Cabeçalho de backup no final do disco
Suporte a SO Todo Linux, Windows XP+ Linux kernel 2.6.25+, Windows Vista+, macOS
Suporte a ferramentas fdisk, parted, gdisk parted, gdisk, fdisk (desde util-linux 2.23)
Recuperação Mais difícil Cabeçalho GPT de backup permite recuperação

Regra geral: Use GPT para qualquer novo disco em 2025. O limite de 128 partições do GPT, resiliência via cabeçalho de backup e ausência do limite de 2 TB fazem dele o padrão correto. Use MBR apenas quando for necessário para sistemas muito antigos ou hardware embarcado que exige especificamente.

Particionamento com fdisk

fdisk é uma ferramenta interativa orientada por menus, incluída no util-linux. Versões modernas (util-linux 2.23+) suportam GPT, tornando-o uma escolha flexível para a maioria das cargas de trabalho.

Inspecionar discos existentes

# Listar todos os dispositivos de bloco com tamanhos e tipos
lsblk

# Mostrar informações detalhadas de partições
fdisk -l

# Mostrar um disco específico
fdisk -l /dev/sdb

Criar uma partição GPT com fdisk

sudo fdisk /dev/sdb

Dentro do prompt interativo:

Command (m for help): g        # Criar uma nova tabela de partições GPT (use 'o' para MBR)
Created a new GPT disklabel (GUID: ...).

Command (m for help): n        # Nova partição
Partition number (1-128, default 1): 1
First sector (2048-..., default 2048): [Enter]
Last sector, +/-sectors or +/-size{K,M,G,T,P}: +100G   # Dimensionar a partição

Command (m for help): t        # Alterar tipo de partição (opcional)
Selected partition 1
Partition type or alias (type L to list all): 20   # Sistema de arquivos Linux

Command (m for help): p        # Visualizar a tabela de partições antes de gravar

Command (m for help): w        # Gravar alterações e sair

Após gravar, o kernel é notificado. Se não for, execute partprobe /dev/sdb ou udevadm settle para forçar uma releitura.

Principais comandos do fdisk

Tecla Ação
m Mostrar menu de ajuda
g Nova tabela de partições GPT
o Nova tabela de partições MBR
n Nova partição
d Excluir partição
t Alterar tipo de partição
p Imprimir tabela de partições
w Gravar e sair
q Sair sem salvar

Particionamento com parted

parted suporta MBR e GPT e é programável — ideal para scripts de automação e ferramentas de provisionamento como Ansible ou Terraform. Também lida com discos maiores que 2 TB sem problemas.

Modo interativo

sudo parted /dev/sdb
(parted) mklabel gpt                  # Criar tabela de partições GPT
(parted) mkpart primary ext4 0% 100%  # Partição única cobrindo todo o disco
(parted) print                        # Verificar
(parted) quit

Modo não-interativo (programável)

# Criar tabela GPT
sudo parted -s /dev/sdb mklabel gpt

# Criar uma única partição usando 100% do espaço do disco
sudo parted -s /dev/sdb mkpart primary ext4 0% 100%

# Criar duas partições: 50 GB de dados, restante para logs
sudo parted -s /dev/sdb mkpart primary ext4 0% 50GB
sudo parted -s /dev/sdb mkpart primary ext4 50GB 100%

O flag -s suprime prompts interativos, tornando o parted seguro para uso em automação.

Alinhamento do parted

Sempre use limites baseados em porcentagem (0%, 100%, 50%) ou valores em MiB/GiB em vez de números brutos de setores. Isso garante o alinhamento correto de setores 4K, que importa para desempenho de SSD e NVMe.

# Verificar alinhamento após criar partições
sudo parted /dev/sdb align-check optimal 1
# Saída: 1 aligned

Formatando Partições com mkfs

Após criar uma partição, você deve criar um sistema de arquivos nela. A escolha do sistema de arquivos depende da sua carga de trabalho.

# ext4 — uso geral, mais compatível
sudo mkfs.ext4 /dev/sdb1

# xfs — alto desempenho, preferido para arquivos grandes e bancos de dados
sudo mkfs.xfs /dev/sdb1

# btrfs — copy-on-write, snapshots, compressão
sudo mkfs.btrfs /dev/sdb1

# Adicionar um rótulo (torna as entradas do fstab mais legíveis)
sudo mkfs.ext4 -L data /dev/sdb1
Sistema de Arquivos Melhor Para Tamanho Máximo de Arquivo Tamanho Máximo do Volume
ext4 Uso geral, discos de VM 16 TB 1 EB
xfs Bancos de dados, arquivos grandes 8 EB 8 EB
btrfs Snapshots, NAS, servidores domésticos 16 EB 16 EB
vfat/FAT32 Pendrives USB, partições EFI 4 GB 2 TB

Montagem e Montagens Persistentes com /etc/fstab

Uma partição montada manualmente desaparece após a reinicialização. Para persistir a montagem, adicione-a ao /etc/fstab. Sempre use UUIDs em vez de nomes de dispositivos como /dev/sdb1 — os nomes de dispositivos podem mudar após reinicializações ou quando discos são adicionados ou removidos.

Obter o UUID

sudo blkid /dev/sdb1
# Saída: /dev/sdb1: UUID="a1b2c3d4-..." TYPE="ext4" PARTLABEL="primary"

# Alternativa: mostrar todos os UUIDs dos dispositivos de bloco
lsblk -o NAME,UUID,FSTYPE,SIZE,MOUNTPOINT

Criar o ponto de montagem e montar imediatamente

sudo mkdir -p /mnt/data
sudo mount /dev/sdb1 /mnt/data

# Verificar
df -h /mnt/data

Adicionar ao /etc/fstab

Abra /etc/fstab com seu editor:

sudo nano /etc/fstab

Adicione uma linha usando este formato:

# <dispositivo>                          <ponto de montagem>  <tipo>  <opções>          <dump> <pass>
UUID=a1b2c3d4-e5f6-7890-abcd-ef1234567890  /mnt/data            ext4    defaults,nofail   0      2

Opções críticas explicadas:

Opção Significado
defaults rw, suid, dev, exec, auto, nouser, async
nofail O boot é bem-sucedido mesmo se o disco estiver ausente (essencial para discos não-root)
noatime Ignora atualizações de tempo de acesso — melhora a vida útil e desempenho do SSD
0 (dump) 0 = não fazer dump; 1 = incluir no backup dump
2 (pass) Ordem do fsck: 0 = ignorar, 1 = somente root, 2 = verificar após root

Verificar a entrada do fstab sem reinicializar

# Desmontar primeiro
sudo umount /mnt/data

# Testar fstab (monta todas as entradas)
sudo mount -a

# Confirmar
df -h /mnt/data

Se mount -a não retornar erros, a entrada é válida e sobreviverá a uma reinicialização.

Cenário Real: Adicionando um Disco de Dados a um Servidor Web de Produção

Você tem um servidor web de produção rodando Ubuntu 22.04. O disco raiz está quase cheio porque /var/www cresceu para 180 GB. Você conecta um novo SSD de 500 GB como /dev/sdb e quer mover o conteúdo web para ele sem tempo de inatividade.

Passo 1 — Identificar e particionar o novo disco:

lsblk
# Confirmar que /dev/sdb é o novo disco de 500GB sem partições

sudo parted -s /dev/sdb mklabel gpt
sudo parted -s /dev/sdb mkpart primary ext4 0% 100%
sudo partprobe /dev/sdb

Passo 2 — Formatar e rotular:

sudo mkfs.ext4 -L webdata /dev/sdb1

Passo 3 — Copiar dados existentes para o novo disco:

sudo mkdir /mnt/newwww
sudo mount /dev/sdb1 /mnt/newwww
sudo rsync -av --progress /var/www/ /mnt/newwww/

Passo 4 — Trocar a montagem (com mínimo tempo de inatividade):

sudo umount /mnt/newwww

# Obter UUID
sudo blkid /dev/sdb1

# Editar /etc/fstab — adicionar a nova montagem para /var/www
# UUID=xxxx-xxxx  /var/www  ext4  defaults,nofail,noatime  0  2

# Mover dados antigos para fora do caminho e remontar
sudo mv /var/www /var/www.bak
sudo mkdir /var/www
sudo mount -a

# Verificar se o servidor web consegue ler os arquivos
ls /var/www

Passo 5 — Validar e limpar:

df -h /var/www
# /dev/sdb1  500G  180G  320G  36%  /var/www

# Após confirmar que tudo funciona, remover o backup
sudo rm -rf /var/www.bak

Armadilhas e Casos Especiais

Deriva de nome de dispositivo: /dev/sdb pode se tornar /dev/sdc após uma reinicialização se outro disco for adicionado. Sempre use UUIDs no /etc/fstab e em scripts — nunca caminhos de dispositivos sem UUID.

Tabela de partições não visível imediatamente: Após gravar alterações com fdisk ou parted, o kernel pode não reler imediatamente a tabela de partições se o disco estiver em uso. Execute sudo partprobe /dev/sdb ou reinicialize.

Alinhamento de setor 4K: Ferramentas mais antigas usam alinhamento baseado em cilindros, o que causa desalinhamento em drives modernos de setor 4K. Use a sintaxe de porcentagem do parted ou o alinhamento de setor padrão do fdisk (2048 setores = 1 MiB).

ext4 em discos grandes: Para volumes maiores que 16 TB, mude para xfs. O comando mkfs.ext4 irá avisá-lo, mas é fácil ignorar.

nofail ausente em discos não-root: Sem nofail, um disco secundário ausente fará o sistema entrar em modo de emergência no boot. Sempre adicione nofail a qualquer entrada fstab que não seja root.

GPT em sistema BIOS sem partição de boot BIOS: Ao usar GPT com GRUB em sistema não-UEFI, você precisa de uma pequena partição (1 MiB) não formatada com tipo BIOS boot (código ef02 no gdisk ou tipo bios_grub no parted). Sem ela, o GRUB não consegue instalar seu stage 2.

Solução de Problemas

mount: /mnt/data: can't read superblock — O sistema de arquivos não foi criado, ou foi criado no dispositivo errado. Execute file -s /dev/sdb1 para verificar se um sistema de arquivos existe.

mount: wrong fs type, bad option, bad superblock — Incompatibilidade entre o tipo de sistema de arquivos no fstab e o tipo real no disco. Execute blkid /dev/sdb1 para verificar o campo TYPE e corrija a entrada do fstab.

WARNING: Re-reading the partition table failed — O kernel não conseguiu atualizar sua visão da tabela de partições porque o disco está ocupado. Se isso acontecer em um disco diferente do disco de boot, execute partprobe ou reinicialize.

UUID muda após mkfs — Cada chamada de mkfs atribui um novo UUID. Se você reformatar uma partição e não atualizar o /etc/fstab, o sistema falhará ao montá-la. Sempre execute blkid após formatar e atualize o fstab imediatamente.

parted: Error: Partition(s) on /dev/sdb are being used — Uma ou mais partições no disco estão montadas atualmente. Desmonte todas elas antes de rotular novamente ou redimensionar.

Resumo

  • Escolha GPT para todos os novos discos em 2025 — suporta 128 partições, discos além de 2 TB e fornece um cabeçalho de tabela de partições de backup.
  • Use fdisk para particionamento interativo; use parted quando precisar de scripting, automação ou discos maiores que 2 TB.
  • Sempre formate uma nova partição com mkfs antes de montar — uma partição bruta não tem sistema de arquivos.
  • Use UUID (não nomes de dispositivos como /dev/sdb1) no /etc/fstab para garantir que as montagens sobrevivam à reordenação de discos.
  • Adicione nofail a todas as entradas fstab não-root para que um disco ausente não impeça o sistema de inicializar.
  • Verifique cada alteração no fstab com mount -a antes de reinicializar — uma entrada ruim pode tornar o sistema sem boot.
  • Alinhe partições aos limites de MiB (sintaxe de porcentagem do parted ou padrões do fdisk) para desempenho ideal em SSD e NVMe.

Artigos Relacionados