Ubuntu Particionar e Formatar

Um disco novo chega "cru": o Ubuntu enxerga o aparelho, mas não consegue guardar arquivos nele. Para usar, você faz três coisas: cria uma tabela de partições, cria uma ou mais partições e formata cada partição com um sistema de arquivos. Nesta aula você faz tudo isso com fdisk, parted e mkfs.

Esta aula apaga dados

Particionar e formatar destroem o que estiver no disco, sem lixeira e sem "desfazer". Pratique primeiro no laboratório seguro mostrado abaixo. Num disco real, confira o nome do dispositivo duas vezes antes de apertar Enter.

Você vai aprender

A diferença entre disco, tabela de partições, partição e sistema de arquivos.
Como montar um laboratório sem risco com arquivos-imagem.
Como identificar o disco certo com lsblk.
Particionar com fdisk (interativo) e com parted (numa linha só).
Formatar com mkfs.ext4 e outros formatos, e criar swap.

Os exemplos acontecem na máquina fictícia servidor, com a usuária ana. O disco do sistema é o /dev/sda e o disco novo é o /dev/sdb.

Conceito: o terreno, os lotes e a casa

Pense num disco como um terreno. Antes de construir, é preciso registrar o mapa dos lotes, depois dividir o terreno em lotes e, por fim, construir em cada lote.

Peça	Analogia	No Linux
Disco	O terreno inteiro	`/dev/sdb`, `/dev/nvme1n1`
Tabela de partições	O mapa que diz onde começa e termina cada lote	GPT (moderna) ou MBR/DOS (antiga)
Partição	Um lote	`/dev/sdb1`, `/dev/nvme1n1p1`
Sistema de arquivos	A casa construída no lote, com cômodos e portas	`ext4`, `xfs`, `vfat`, `exfat`
Ponto de montagem	O endereço da casa	`/mnt/dados`, `/srv`

GPT ou MBR?

	GPT	MBR (DOS)
Tamanho máximo do disco	Praticamente ilimitado	2 TiB
Quantidade de partições	128 por padrão	4 primárias (ou 3 + estendida)
Quando usar	Sempre, em disco novo	Pendrive para aparelhos muito antigos

Nomes dos dispositivos

/dev/sda, /dev/sdb…: discos SATA, USB e discos de VM. As partições ganham um número: /dev/sdb1, /dev/sdb2.
/dev/nvme0n1, /dev/nvme1n1…: SSDs NVMe. As partições ganham p + número: /dev/nvme1n1p1.
/dev/vda: disco virtual em algumas VMs (KVM).
/dev/loop0…: "discos" que são arquivos. Os snaps usam vários; ignore-os.

Laboratório seguro: um disco que é só um arquivo

O fdisk, o parted e o mkfs aceitam um arquivo comum no lugar de um disco. Assim você treina tudo sem sudo e sem chance de estragar nada. Comece criando um "disco" de 10 GB:

truncate: Programa que muda o tamanho de um arquivo.
-s 10G: -s (size) define o tamanho: 10 GB.
disco.img: O arquivo que vai fazer o papel de disco.

$ truncate -s 10G disco.img
$ ls -lh disco.img
-rw-rw-r-- 1 ana ana 10G Oct 15 10:30 disco.img       « parece ter 10 GB…
$ du -h disco.img
0       disco.img                                     « …mas não ocupa nada ainda

O arquivo é "esparso": o espaço só é gasto quando algo é gravado. Tudo o que você fizer a seguir com /dev/sdb pode ser feito trocando /dev/sdb por disco.img e tirando o sudo.

Outra opção: uma VM com disco extra

No VirtualBox, em Configurações → Armazenamento, adicione um segundo disco virtual. Dentro da VM ele aparece como /dev/sdb, igual a um disco de verdade. Se algo der errado, só a VM sofre.

Passo 1: identificar o disco certo

Antes de qualquer coisa, descubra o nome do disco novo. O erro mais grave desta aula é formatar o disco do sistema por engano.

lsblk: "list block devices": lista discos e partições.
-o NAME,SIZE,TYPE,FSTYPE,MOUNTPOINTS,MODEL: Escolhe as colunas: nome, tamanho, tipo, formato, onde está montado e modelo.
-e 7: Esconde os dispositivos do tipo 7 (os loop dos snaps).

$ lsblk -e 7 -o NAME,SIZE,TYPE,FSTYPE,MOUNTPOINTS,MODEL
NAME     SIZE TYPE FSTYPE MOUNTPOINTS MODEL
sda       64G disk                    QEMU HARDDISK
├─sda1     1G part vfat   /boot/efi                    « disco do sistema: NÃO mexa
└─sda2    63G part ext4   /
sdb      100G disk                    QEMU HARDDISK    « o novo: sem partições, sem montagem

Como reconhecer o disco novo:

Tem o tamanho que você comprou ou criou.
Não tem linhas de partição (├─) embaixo dele.
A coluna MOUNTPOINTS está vazia.

Confirme pelo antes e depois

Rode lsblk antes de ligar o disco (ou o pendrive) e de novo depois. O nome que apareceu é o novo.

Passo 2: particionar com `fdisk`

fdisk (de fixed disk) é interativo: você digita uma letra por vez, e ele pergunta o resto. Nada é gravado até você digitar w. Se errar, digite q para sair sem salvar.

sudo: Mexer em discos exige administrador. No laboratório com arquivo, não precisa.
fdisk: O programa de particionamento.
/dev/sdb: O disco inteiro (sem número no fim). No laboratório: disco.img.

Os comandos do fdisk

Tecla	O que faz
`m`	Mostra o menu de ajuda
`p`	Mostra (print) a tabela atual
`g`	Cria uma tabela GPT nova e vazia
`o`	Cria uma tabela MBR/DOS nova e vazia
`n`	Cria uma partição nova (new)
`d`	Apaga (delete) uma partição
`t`	Muda o tipo da partição (ex.: swap, EFI)
`w`	Grava (write) e sai. A partir daqui, não tem volta
`q`	Sai (quit) sem gravar nada

Vamos dividir o disco em duas partições: uma de 4 GB e outra com o resto. Em cada pergunta, Enter aceita o valor padrão, que aparece no fim da pergunta.

$ sudo fdisk /dev/sdb
Bem-vindo ao fdisk (util-linux 2.41.3).
As alterações permanecerão apenas na memória, até que você decida gravá-las.
Tenha cuidado antes de usar o comando de gravação.

A unidade não contém uma tabela de partição conhecida.                   « disco virgem
Criado um novo rótulo de disco DOS (MBR) com o identificador de disco 0xf56cdee0.

Comando (m para ajuda): g                                               « tabela GPT nova
Criado um novo rótulo de disco GPT (GUID: AFD81F06-B177-49A7-B294-5629214B70D0).

Comando (m para ajuda): n                                               « partição nova
Número da partição (1-128, padrão 1):                                   « Enter
Primeiro setor (2048-209715166, padrão 2048):                           « Enter
Último setor, +/-setores ou +/-tamanho{K,M,G,T,P} (2048-209715166, padrão 209713151): +4G

Criada uma nova partição 1 do tipo "Linux filesystem" e de tamanho 4 GiB.

Comando (m para ajuda): n
Número da partição (2-128, padrão 2):                                   « Enter
Primeiro setor (8390656-209715166, padrão 8390656):                     « Enter
Último setor, +/-setores ou +/-tamanho{K,M,G,T,P} (8390656-209715166, padrão 209713151):   « Enter = o resto

Criada uma nova partição 2 do tipo "Linux filesystem" e de tamanho 96 GiB.

Comando (m para ajuda): p
Disco /dev/sdb: 100 GiB, 107374182400 bytes, 209715200 setores
Tipo de rótulo do disco: gpt

Dispositivo   Início       Fim   Setores Tamanho Tipo
/dev/sdb1       2048   8390655   8388608      4G Linux sistema de arquivos
/dev/sdb2    8390656 209713151 201322496     96G Linux sistema de arquivos

Comando (m para ajuda): w                                               « grava de verdade
A tabela de partição foi alterada.
Chamando ioctl() para reler tabela de partição.
Sincronizando discos.

Entendendo a pergunta do "último setor": o disco é dividido em setores de 512 bytes. Em vez de calcular setores, você escreve o tamanho com +: +4G significa "4 GB a partir do início". Deixar em branco usa todo o espaço livre.

Confira o resultado:

$ lsblk /dev/sdb
NAME   MAJ:MIN RM  SIZE RO TYPE MOUNTPOINTS
sdb      8:16   0  100G  0 disk
├─sdb1   8:17   0    4G  0 part                         « partições novas, ainda sem formato
└─sdb2   8:18   0   96G  0 part

O que o comando devolve

O fdisk não altera o disco até o w. Se você sair com q, o código de saída é 0 e nada mudou. Se ele não conseguir reler a tabela (o disco está em uso), mostra Releitura da tabela de partição falhou.; nesse caso, rode sudo partprobe /dev/sdb ou reinicie.

Forma alternativa: `parted` numa linha só

O parted faz o mesmo trabalho, mas aceita tudo como argumentos. É a forma preferida em scripts, porque não exige ninguém digitando.

sudo parted: O programa, como administrador.
-s: script: não faz perguntas.
/dev/sdb: O disco inteiro.
mklabel gpt: Cria uma tabela GPT nova (apaga a anterior).
mkpart dados ext4 0% 100%: Cria uma partição chamada "dados", marcada como ext4, do início (0%) ao fim (100%).
print: Mostra o resultado.

$ sudo parted -s /dev/sdb mklabel gpt mkpart dados ext4 0% 100% print
Modelo: QEMU QEMU HARDDISK (scsi)
Disco /dev/sdb: 107GB
Tamanho do setor (lógico/físico): 512B/512B
Tabela de Partição: gpt
Opções de disco:

Número  Início  Fim    Tamanho  Sistema de arquivos  Nome   Opções
 1      1049kB  107GB  107GB                         dados          « ainda sem formato

O "ext4" do mkpart não formata

No mkpart, o tipo é só uma etiqueta na tabela. A partição continua vazia até você rodar o mkfs. Usar 0% e 100% faz o parted alinhar a partição corretamente, sem você calcular setores.

Qual ferramenta usar?

Ferramenta	Como é	Melhor quando…
`fdisk`	Interativa, menu de letras	Você está aprendendo ou quer ver cada passo.
`parted -s`	Uma linha, sem perguntas	Scripts, automação, discos grandes.
`gdisk`	Interativa, só GPT	Consertar tabelas GPT danificadas.
Discos (GNOME) / GParted	Gráfica	Você está no desktop e prefere clicar.

Passo 3: formatar com `mkfs`

mkfs vem de make filesystem, "criar sistema de arquivos". Existe uma versão para cada formato: mkfs.ext4, mkfs.xfs, mkfs.vfat…

sudo mkfs.ext4: Cria um sistema de arquivos ext4 (o padrão do Ubuntu).
-L dados: -L (label) dá um nome à partição. Aparece no lsblk -f e no gerenciador de arquivos.
/dev/sdb2: A partição (com número no fim), não o disco.

$ sudo mkfs.ext4 -L dados /dev/sdb2
mke2fs 1.47.2 (1-Jan-2025)
A descartar blocos de dispositivo: pronto
A criar sistema de ficheiros com 25165312 4k blocos e 6291456 inodes
UUID do sistema de ficheiros: 3597462d-758a-453e-a4ea-2e8efd6c6cbf   « identificador único
Cópias de segurança de superblocos gravadas em blocos:
	32768, 98304, 163840, 229376, 294912, 819200, 884736, 1605632, 2654208,
	4096000, 7962624, 11239424, 20480000, 23887872

A alocar tabelas de grupo: pronto
Gravando tabelas inode: pronto
A criar diário (131072 blocos): concluído
Escrevendo superblocos e informações de contabilidade de sistema de arquivos: concluído

A tradução mistura português de Portugal ("ficheiros", "A criar") e do Brasil: é assim que o mke2fs aparece no Ubuntu 26.04. O que importa:

UUID: o "RG" da partição. É ele que você usa no /etc/fstab (veja mount e fstab).
Cópias de superblocos: backups da estrutura do disco, usados pelo fsck para consertar danos.
Diário (journal): registro que protege contra corrupção em quedas de energia.

Confira o formato e o UUID:

$ lsblk -f /dev/sdb
NAME   FSTYPE FSVER LABEL UUID                                 FSAVAIL FSUSE% MOUNTPOINTS
sdb
├─sdb1
└─sdb2 ext4   1.0   dados 3597462d-758a-453e-a4ea-2e8efd6c6cbf

Outros formatos

Formato	Comando	Use para
ext4	`sudo mkfs.ext4 -L dados /dev/sdb1`	Discos Linux em geral (padrão)
xfs	`sudo mkfs.xfs -L dados /dev/sdb1`	Servidores com arquivos muito grandes; não pode ser encolhido
btrfs	`sudo mkfs.btrfs -L dados /dev/sdb1`	Snapshots e compressão embutidos
vfat (FAT32)	`sudo mkfs.vfat -n PENDRIVE /dev/sdc1`	Pendrives para qualquer aparelho; arquivo máximo de 4 GB
exfat	`sudo mkfs.exfat -L PENDRIVE /dev/sdc1`	Pendrives e HDs externos compartilhados com Windows e Mac
ntfs	`sudo mkfs.ntfs -f -L Dados /dev/sdc1`	Disco usado principalmente no Windows (pacote `ntfs-3g`)

No laboratório

Com o arquivo-imagem, o mkfs.ext4 roda sem sudo:

$ mkfs.ext4 -L teste disco.img
mke2fs 1.47.2 (1-Jan-2025)
A criar sistema de ficheiros com 2621440 4k blocos e 655360 inodes
…
$ file disco.img
disco.img: Linux rev 1.0 ext4 filesystem data, UUID=9c1e…, volume name "teste" (extents) (64bit) (large files) (huge files)

Apagar assinaturas antigas: `wipefs`

Um disco reaproveitado pode ter restos de formatos antigos (RAID, LVM, ZFS) que confundem o sistema. wipefs (de wipe filesystem signatures) lista e apaga essas "assinaturas".

$ sudo wipefs /dev/sdb                    « só lista, não apaga
DEVICE OFFSET       TYPE UUID LABEL
sdb    0x200        gpt
sdb    0x18fffffe00 gpt
sdb    0x1fe        PMBR
$ sudo wipefs -a /dev/sdb                 « -a (all) apaga todas
/dev/sdb: 8 bytes foram apagados na posição 0x00000200 (gpt): 45 46 49 20 50 41 52 54
/dev/sdb: 8 bytes foram apagados na posição 0x18fffffe00 (gpt): 45 46 49 20 50 41 52 54
/dev/sdb: 2 bytes foram apagados na posição 0x000001fe (PMBR): 55 aa

Atenção

wipefs -a faz o disco "esquecer" todas as partições na hora. Os dados ainda estão lá fisicamente, mas o sistema deixa de enxergá-los.

Swap: memória extra no disco

Swap é um espaço no disco que o Linux usa quando a memória RAM enche. É bem mais lento que a RAM, mas evita que programas sejam encerrados à força. O Ubuntu cria um arquivo /swap.img na instalação. Veja como está:

$ swapon --show
NAME      TYPE SIZE USED PRIO
/swap.img file   4G 512M   -2                « arquivo de 4 GB, 512 MB em uso

Criar um arquivo de swap

Reserve o espaço. fallocate -l 8G cria um arquivo de 8 GB de uma vez.
```
$ sudo fallocate -l 8G /swapfile
```
Proteja o arquivo. Só o root pode ler: a swap pode conter senhas que estavam na memória.
```
$ sudo chmod 600 /swapfile
```

Formate como swap e ative.

$ sudo mkswap /swapfile
Configurando espaço de swap versão 1, tamanho = 8 GiB (8589930496 bytes)
nenhum rótulo, UUID=6b0f3c2e-1a7d-4f5b-9c8e-2d4a6f8b0c1e
$ sudo swapon /swapfile
$ swapon --show
NAME      TYPE SIZE USED PRIO
/swap.img file   4G 512M   -2
/swapfile file   8G   0B   -3                « a nova swap

Torne permanente. Adicione a linha no /etc/fstab para ela voltar após reiniciar:

$ echo '/swapfile none swap sw 0 0' | sudo tee -a /etc/fstab
/swapfile none swap sw 0 0

Quanto o sistema usa a swap: `vm.swappiness`

Um número de 0 a 200. O padrão é 60. Valores menores fazem o Linux preferir a RAM e usar a swap só quando necessário.

$ cat /proc/sys/vm/swappiness
60
$ echo 'vm.swappiness=10' | sudo tee /etc/sysctl.d/99-swappiness.conf
vm.swappiness=10
$ sudo sysctl --system | tail -1
vm.swappiness = 10

Quando não funciona

"is mounted; will not make a filesystem here!"

$ sudo mkfs.ext4 /dev/sdb2
mke2fs 1.47.2 (1-Jan-2025)
/dev/sdb2 is mounted; will not make a filesystem here!

O que aconteceu: a partição está montada (em uso). O mkfs se recusa a formatar, para proteger seus dados.

Como confirmar: findmnt /dev/sdb2 mostra onde ela está montada.

Como resolver: se for mesmo a partição certa, desmonte com sudo umount /dev/sdb2 e rode de novo. Esse erro também é um bom momento para conferir se você não digitou o disco errado.

"contains a ext4 file system … Proceder mesmo assim?"

$ sudo mkfs.ext4 /dev/sdb2
mke2fs 1.47.2 (1-Jan-2025)
/dev/sdb2 contains a ext4 file system labelled 'dados'
	last mounted on /mnt/dados on Wed Oct 14 18:02:11 2026
Proceder mesmo assim? (y,N)

O que aconteceu: já existe um sistema de arquivos ali, possivelmente com dados. O padrão (N) cancela.

Como resolver: responda y só se tiver certeza de que pode apagar tudo. A data do "last mounted" ajuda a lembrar o que havia ali.

"O ficheiro … não existe e não foi especificado um tamanho."

$ sudo mkfs.ext4 /dev/sdb3
mke2fs 1.47.2 (1-Jan-2025)
O ficheiro /dev/sdb3 não existe e não foi especificado um tamanho.

O que aconteceu: a partição sdb3 não existe. Ou você errou o número, ou ela ainda não foi criada.

Como resolver: confira com lsblk /dev/sdb. Se as partições acabaram de ser criadas e não aparecem, rode sudo partprobe /dev/sdb.

Formatou o disco inteiro em vez da partição

O que aconteceu: rodou mkfs.ext4 /dev/sdb (sem número). Funciona, mas apaga a tabela de partições: o disco vira um sistema de arquivos só, sem partições.

Como resolver: se não há dados ainda, recomece: sudo wipefs -a /dev/sdb e particione de novo. Regra prática: fdisk e parted recebem o disco (/dev/sdb); mkfs recebe a partição (/dev/sdb1).

Referência rápida

Comando	O que faz
`lsblk -f`	Lista discos e partições com formato, rótulo e UUID
`sudo fdisk -l /dev/sdb`	Mostra a tabela de partições sem entrar no modo interativo
`sudo fdisk /dev/sdb`	Particiona de forma interativa
`sudo parted -s /dev/sdb mklabel gpt`	Cria tabela GPT nova
`sudo parted -s /dev/sdb mkpart NOME ext4 0% 100%`	Cria uma partição ocupando o disco todo
`sudo partprobe /dev/sdb`	Pede ao kernel para reler a tabela de partições
`sudo mkfs.ext4 -L NOME /dev/sdb1`	Formata em ext4 com rótulo
`sudo e2label /dev/sdb1 NOVO`	Troca o rótulo de uma partição ext4
`sudo wipefs -a /dev/sdb`	Apaga assinaturas de formatos antigos
`sudo resize2fs /dev/sdb1`	Ajusta o ext4 ao tamanho da partição (após aumentá-la)
`sudo mkswap` / `swapon` / `swapoff`	Prepara, liga e desliga swap

Exercícios

1. Disco ou partição?

Complete para formatar a primeira partição do disco /dev/sdb em ext4:

sudo mkfs.ext4

2. Tabela nova

Dentro do fdisk, qual letra cria uma tabela GPT nova?

Comando (m para ajuda):

3. Laboratório

Complete para criar um arquivo de 5 GB que servirá de disco de treino:

truncate treino.img

4. Você digitou várias coisas no fdisk e percebeu que estava no disco errado. O que fazer?

Digitar w e depois desfazer. Fechar o terminal e torcer. Digitar d em todas as partições. Digitar q: sai sem gravar nada.

5. Qual formato usar num pendrive que vai ser lido no Windows, no Mac e no Linux, com arquivos de 6 GB?

vfat (FAT32) exfat ext4 xfs

Resumo

Ordem: tabela (GPT) → partição → formato (mkfs) → montagem.
Identifique o disco com lsblk antes de tudo; o disco novo não tem partições nem montagem.
fdisk é interativo e só grava no w; q sai sem mudar nada. parted -s faz tudo numa linha.
fdisk/parted recebem o disco (/dev/sdb); mkfs recebe a partição (/dev/sdb1).
Treine com truncate -s 10G disco.img: as mesmas ferramentas funcionam num arquivo, sem risco.