Usando o Comando `mkfs` no Linux: Um Guia Completo para Formatar Discos e Partições

O `mkfs` (make filesystem) é o principal utilitário Linux para escrever uma estrutura de sistema de ficheiros num dispositivo de bloco — seja um disco bruto, uma partição ou um volume lógico. Inicializa o superbloco, as tabelas de inodes, os grupos de blocos e as estruturas de journal necessárias antes de qualquer dado poder ser escrito nesse dispositivo.

Antes de tocar em qualquer disco, compreenda isto: `mkfs` é uma operação destrutiva e irreversível. Não se limita a apagar uma entrada da tabela de partições — sobrescreve metadados críticos no disco. Executá-lo no dispositivo errado, mesmo que brevemente, torna os dados existentes irrecuperáveis sem ferramentas forenses. Verifique o dispositivo de destino com `lsblk` ou `blkid` antes de cada invocação.

O que o `mkfs` Faz Internamente

Quando executa `mkfs -t ext4 /dev/sdb1`, o kernel não se limita a “formatar” a partição no sentido do Windows. O comando chama o binário específico do sistema de ficheiros apropriado (neste caso `mkfs.ext4`, que é na verdade `mke2fs` com as predefinições ext4) e executa o seguinte:

• Escreve o superbloco e cópias de superbloco de reserva em offsets fixos de grupos de blocos
• Aloca e inicializa a tabela de inodes em todos os grupos de blocos
• Cria a tabela de descritores de grupos de blocos
• Inicializa o journal (para sistemas de ficheiros com journaling como ext4 e XFS)
• Escreve o inode do diretório raiz (inode 2 para ext4)
• Grava um UUID no sistema de ficheiros para identificação persistente

Esta distinção é importante em discos grandes. Formatar uma partição ext4 de 4 TB com inicialização completa da tabela de inodes pode demorar vários minutos. O XFS, por contraste, adia a maior parte deste trabalho para o tempo de execução, tornando o seu `mkfs.xfs` quase instantâneo independentemente do tamanho do volume.

Identificar o Dispositivo Correto Antes de Formatar

Nunca adivinhe um nome de dispositivo. Utilize as seguintes ferramentas para mapear hardware físico para nós de dispositivo do kernel.

Utilizar `lsblk`

“`bash

lsblk -o NAME,SIZE,FSTYPE,LABEL,UUID,MOUNTPOINT

“`

Exemplo de saída:

“`

NAME SIZE FSTYPE LABEL UUID MOUNTPOINT

sda 100G

├─sda1 20G ext4 a1b2c3d4-… /

└─sda2 80G ext4 e5f6a7b8-… /home

sdb 500G

└─sdb1 500G

“`

Um campo `FSTYPE` vazio confirma que `/dev/sdb1` não tem sistema de ficheiros existente — é seguro formatar.

Utilizar `blkid`

“`bash

sudo blkid /dev/sdb1

“`

Se o comando não devolver nenhuma saída, a partição não contém nenhuma assinatura de sistema de ficheiros reconhecida. Se devolver um tipo, está prestes a sobrescrever dados existentes.

Utilizar `fdisk -l`

“`bash

sudo fdisk -l /dev/sdb

“`

Isto revela os limites das partições, os tipos de partição e se o disco utiliza MBR ou GPT. Se `/dev/sdb` não mostrar nenhuma tabela de partições, poderá ser necessário particioná-lo primeiro com `fdisk`, `gdisk` ou `parted` antes de executar `mkfs`.

Sintaxe Principal e Padrões de Invocação do `mkfs`

A sintaxe canónica é:

“`bash

mkfs -t <filesystem_type> [options] <device>

“`

No entanto, o `mkfs` em si é um invólucro simples. Cada tipo de sistema de ficheiros inclui o seu próprio binário dedicado:

Chamar `mkfs -t ext4` e chamar `mkfs.ext4` diretamente são funcionalmente idênticos — o primeiro simplesmente resolve para o segundo. Em scripts de produção, prefira o alias explícito (`mkfs.ext4`) para tornar a intenção inequívoca.

Seleção do Tipo de Sistema de Ficheiros: Comparação Técnica

Escolher o sistema de ficheiros errado para uma carga de trabalho é um erro comum e dispendioso. A tabela seguinte mapeia as características dos sistemas de ficheiros para casos de uso reais.

Caso extremo crítico — a Partição do Sistema EFI: A ESP deve ser formatada como `vfat` (especificamente FAT32). Utilizar qualquer outro sistema de ficheiros aqui impedirá o firmware UEFI de localizar o bootloader. Formate sempre a ESP com:

“`bash

sudo mkfs.vfat -F 32 /dev/sda1

“`

O sinalizador `-F 32` força explicitamente o FAT32 em vez do FAT16, o que é importante para partições ESP maiores que 32 MiB.

Exemplos Práticos do `mkfs` com Opções de Nível de Produção

Exemplo 1: Criar um Sistema de Ficheiros ext4 com Parâmetros Ajustados

“`bash

sudo mkfs.ext4 -L "data_vol" -m 1 -E lazy_itable_init=0,lazy_journal_init=0 /dev/sdb1

“`

O que cada sinalizador faz:

• `-L "data_vol"` — atribui uma etiqueta persistente, permitindo que as entradas do `/etc/fstab` utilizem `LABEL=data_vol` em vez de um caminho de dispositivo bruto (mais seguro em sistemas onde a ordem de enumeração de dispositivos pode mudar)
• `-m 1` — reduz a percentagem de blocos reservados da predefinição de 5% para 1%; num volume de dados de 2 TB, a predefinição desperdiça ~100 GB que apenas o root pode utilizar
• `-E lazy_itable_init=0,lazy_journal_init=0` — força a inicialização completa da tabela de inodes no momento da formatação em vez de a adiar para I/O em segundo plano; crítico para servidores de produção onde a inicialização em segundo plano pode causar picos de I/O inesperados horas após a implementação

Exemplo 2: Criar um Sistema de Ficheiros XFS para um Servidor de Base de Dados

“`bash

sudo mkfs.xfs -L "pg_data" -f /dev/sdb1

“`

• `-f` — força a criação mesmo que seja detetada uma assinatura de sistema de ficheiros existente; utilize apenas quando tiver confirmado que o dispositivo é descartável
• O XFS não suporta redução de tamanho; planeie cuidadosamente o tamanho do volume antes de formatar

Para cargas de trabalho PostgreSQL ou MySQL em XFS, defina também a opção de montagem `noatime` em `/etc/fstab` para eliminar a sobrecarga de escrita do tempo de acesso a inodes em cada operação de leitura.

Exemplo 3: Criar um Sistema de Ficheiros Btrfs com RAID-1 em Dois Dispositivos

“`bash

sudo mkfs.btrfs -L "btrfs_mirror" -d raid1 -m raid1 /dev/sdb /dev/sdc

“`

O Btrfs pode abranger múltiplos dispositivos de bloco nativamente. `-d raid1` espelha dados; `-m raid1` espelha metadados. Esta é uma alternativa legítima ao RAID de software mdadm para ambientes onde a funcionalidade de snapshot e subvolume também é necessária.

Exemplo 4: Criar um Sistema de Ficheiros vFAT para uma Drive USB

“`bash

sudo mkfs.vfat -F 32 -n "BACKUP_USB" /dev/sdc1

“`

• `-n "BACKUP_USB"` — define a etiqueta do volume (as etiquetas FAT32 estão limitadas a 11 caracteres, em maiúsculas)
• `-F 32` — seleciona explicitamente FAT32 em vez de FAT16

Exemplo 5: Criar um Sistema de Ficheiros F2FS num SSD

“`bash

sudo mkfs.f2fs -l "ssd_cache" /dev/sdb1

“`

O F2FS é especificamente concebido para armazenamento flash NAND. Reduz a amplificação de escrita e gere o nivelamento de desgaste ao nível do sistema de ficheiros. Em instâncias de VPS Hosting suportadas por armazenamento NVMe, o F2FS pode superar o ext4 em volumes de cache efémeros com elevada rotatividade de escrita.

Formatar um Disco Inteiro Sem Tabela de Partições

Em cenários específicos — volumes físicos LVM, OSDs Ceph ou dispositivos de armazenamento de propósito único — pode escrever um sistema de ficheiros diretamente num disco inteiro em vez de numa partição:

“`bash

sudo mkfs.ext4 /dev/sdb

“`

Quando isto é apropriado:

• O disco é dedicado a um único propósito e a flexibilidade de particionamento não é necessária
• Está a preparar um disco para LVM (`pvcreate` trata isto de forma diferente, mas o conceito é semelhante)
• Está a criar uma imagem de sistema de ficheiros loopback

Quando isto é inapropriado:

• Qualquer disco que precise de arrancar (requer uma tabela de partições com um sinalizador de arranque)
• Qualquer disco partilhado entre múltiplos sistemas de ficheiros ou sistemas operativos
• Discos em sistemas onde as regras udev ou as ferramentas de infraestrutura cloud esperam uma tabela de partições

Montar a Partição Formatada e Torná-la Persistente

A formatação cria o sistema de ficheiros; a montagem torna-o acessível. Utilize sempre referências baseadas em UUID em `/etc/fstab` em vez de nomes de dispositivos, porque os nomes de dispositivos (`/dev/sdb1`) não têm garantia de ser estáveis entre reinicializações em sistemas com múltiplos discos ou armazenamento hot-plug.

“`bash

Create the mount point

sudo mkdir -p /mnt/data_vol

Mount temporarily to verify

sudo mount /dev/sdb1 /mnt/data_vol

Retrieve the UUID

sudo blkid /dev/sdb1

Output: /dev/sdb1: LABEL="data_vol" UUID="a1b2c3d4-e5f6-7890-abcd-ef1234567890" TYPE="ext4"

Add a persistent, UUID-based fstab entry

echo 'UUID=a1b2c3d4-e5f6-7890-abcd-ef1234567890 /mnt/data_vol ext4 defaults,noatime 0 2' | sudo tee -a /etc/fstab

Validate the fstab entry without rebooting

sudo mount -a

“`

O `0 2` no final da entrada fstab controla o `dump` (utilitário de cópia de segurança, definido como 0 para desativar) e a ordem de passagem do `fsck` (2 significa verificar após o sistema de ficheiros raiz; o raiz deve ser 1).

Verificar a Integridade do Sistema de Ficheiros Após a Formatação

Não assuma que uma formatação foi bem-sucedida sem verificação.

“`bash

Check filesystem type, label, and UUID

lsblk -f /dev/sdb1

For ext4: run e2fsck in read-only check mode

sudo e2fsck -n /dev/sdb1

For XFS: verify the filesystem structure

sudo xfs_repair -n /dev/sdb1

Check available space after mounting

df -hT /mnt/data_vol

“`

O sinalizador `-n` tanto no `e2fsck` como no `xfs_repair` executa uma verificação simulada sem modificar o sistema de ficheiros. É seguro executar num sistema de ficheiros montado para fins de diagnóstico, embora uma reparação completa exija desmontagem prévia.

Referência de Opções Avançadas

Erros Comuns e Como Evitá-los

Formatar um sistema de ficheiros montado: O Linux nem sempre impedirá isto. Executar `mkfs` numa partição montada corrompe o sistema de ficheiros imediatamente e pode causar kernel panics. Verifique sempre o estado de montagem com `mount | grep /dev/sdb1` antes de prosseguir.

Esgotamento de inodes no ext4: Se definir um tamanho de bloco grande (por exemplo, 4096 bytes) num volume que armazenará milhões de ficheiros minúsculos (spools de correio, caches de sessão), esgotará os inodes muito antes do espaço em disco. Utilize `-i 4096` ou `-i 2048` para aumentar a densidade de inodes. Este é um problema particularmente comum em servidores de Email Hosting e servidores web de alto tráfego que armazenam ficheiros por sessão.

XFS e redução de tamanho: Os volumes XFS não podem ser reduzidos após a criação. Se formatar um volume XFS de 2 TB e posteriormente precisar de recuperar espaço, a única opção é fazer cópia de segurança, reformatar e restaurar. Planeie os tamanhos dos volumes XFS de forma conservadora ou utilize thin provisioning LVM por baixo.

Alinhamento de stripe para RAID e SSDs: Formatar sem especificar o alinhamento de stripe num array RAID ou SSD causa I/O desalinhado, degradando significativamente o desempenho. Para um array RAID-5 com um stripe de 512 KB e 4 discos:

“`bash

sudo mkfs.ext4 -E stride=128,stripe-width=384 /dev/md0

“`

Onde `stride = stripe_size / block_size` e `stripe-width = stride * (data_disks)`.

Colisões de UUID após clonagem de disco: Clonar um disco com `dd` duplica o UUID do sistema de ficheiros. Dois dispositivos com UUIDs idênticos causam falhas de montagem e corrupção de dados. Após a clonagem, regenere o UUID:

“`bash

sudo tune2fs -U random /dev/sdb1 # ext4

sudo xfs_admin -U generate /dev/sdb1 # XFS

“`

Esta é uma consideração crítica ao implementar Servidores Dedicados a partir de imagens de disco ou ao provisionar múltiplos nós a partir de um único modelo.

Considerações sobre Sistemas de Ficheiros para Ambientes VPS e Cloud

Em máquinas virtuais e instâncias cloud, o armazenamento subjacente é frequentemente um disco virtual com thin provisioning suportado por um sistema de armazenamento distribuído. Várias decisões do `mkfs` tornam-se mais impactantes neste contexto:

• Suporte a Discard/TRIM: Formate ext4 com `-E discard` ou adicione a opção de montagem `discard` para ativar o TRIM online, que devolve blocos libertados ao pool de armazenamento subjacente e mantém o desempenho ao longo do tempo em instâncias de VPS com cPanel suportadas por SSD.
• Modo de journal: Para aplicações sensíveis à latência, considere o modo de journal `data=writeback` em `/etc/fstab` para ext4. Isto troca a ordenação estrita de dados por menor latência de escrita, aceitável para bases de dados que gerem os seus próprios write-ahead logs.
• Evite formatar swap como sistema de ficheiros: As partições swap utilizam `mkswap`, não `mkfs`. Executar `mkfs` numa partição swap destrói a assinatura swap sem criar um sistema de ficheiros utilizável.

Ao gerir armazenamento em Painéis de Controlo VPS, os volumes de disco adicionais aparecem tipicamente como dispositivos de bloco não formatados. O fluxo de trabalho é sempre: identificar com `lsblk`, particionar se necessário com `fdisk`/`gdisk`, formatar com `mkfs`, montar e persistir em `/etc/fstab`.

Matriz de Decisão: Escolher o Sistema de Ficheiros Correto

Utilize esta matriz para selecionar um sistema de ficheiros com base na sua restrição principal:

Lista de Verificação de Pontos-Chave Técnicos

Antes de executar `mkfs` em qualquer ambiente, percorra esta lista de verificação:

• Confirme o dispositivo de destino com `lsblk -f` e `blkid` — nunca confie na memória ou em suposições
• Desmonte o destino com `umount /dev/sdXN` e verifique com `mount | grep sdX`
• Faça cópia de segurança de todos os dados no dispositivo; `mkfs` não é reversível
• Selecione o tipo de sistema de ficheiros com base na carga de trabalho (consulte a matriz de decisão acima), não por hábito
• Defina uma etiqueta de sistema de ficheiros com `-L` para identificação legível por humanos em registos e `fstab`
• Reduza os blocos reservados em volumes de dados grandes (`-m 1` para ext4) para recuperar espaço utilizável
• Desative a inicialização lazy (`-E lazy_itable_init=0`) em servidores de produção para evitar picos de I/O após implementação
• Utilize UUID em `/etc/fstab`, não nomes de dispositivos, para persistência de montagem
• Valide com `mount -a` após editar `/etc/fstab` para detetar erros antes de reiniciar
• Execute `e2fsck -n` ou `xfs_repair -n` após a formatação para confirmar a integridade do sistema de ficheiros
• Regenere os UUIDs em qualquer disco clonado a partir de uma imagem de modelo

FAQ

P: Posso executar `mkfs` numa partição que está atualmente montada?

R: Tecnicamente o kernel pode permitir, mas fazê-lo corrompe imediatamente o sistema de ficheiros e pode desencadear kernel panics ou perda de dados. Desmonte sempre a partição primeiro e confirme com `mount | grep <device>` antes de executar `mkfs`.

P: Qual é a diferença entre `mkfs.ext4` e `mke2fs`?

R: `mkfs.ext4` é um symlink ou invólucro que chama `mke2fs` com as predefinições `-t ext4`. São funcionalmente idênticos. `mke2fs` é a ferramenta canónica e aceita toda a gama de opções de criação ext2/ext3/ext4.

P: Por que razão a formatação de uma partição ext4 grande demora tanto em comparação com XFS?

R: O ext4 inicializa a tabela de inodes para cada grupo de blocos no momento da formatação (a menos que `lazy_itable_init=1` esteja definido). Num volume de 4 TB, isto envolve escrever gigabytes de dados de tabela de inodes zerados. O XFS adia a inicialização de estruturas para o tempo de execução, fazendo com que `mkfs.xfs` seja concluído em segundos independentemente do tamanho do volume.

P: Como posso alterar uma etiqueta de sistema de ficheiros após a formatação sem reformatar?

R: Para ext4, utilize `sudo tune2fs -L "NewLabel" /dev/sdb1`. Para XFS, utilize `sudo xfs_admin -L "NewLabel" /dev/sdb1`. Para FAT32, utilize `sudo fatlabel /dev/sdb1 NEWLABEL`. Nenhum dado é afetado pela reidentificação.

P: É seguro utilizar `mkfs` num volume lógico LVM?

R: Sim. Os volumes lógicos LVM aparecem como dispositivos de bloco (por exemplo, `/dev/mapper/vg0-lv_data` ou `/dev/vg0/lv_data`) e são tratados de forma idêntica a partições físicas pelo `mkfs`. Este é o fluxo de trabalho padrão para armazenamento Linux de produção: criar o LV com `lvcreate`, formatar com `mkfs`, montar e persistir em `/etc/fstab`.