Réduire la taille d'une image de carte SD d'un Raspberry Pi

Quand tu crée une image de la carte SD d'un Raspberry avec un logiciel comme Win32DiskImager, ça réalise une copie bit à bit de la carte SD ce qui fait que ton fichier image sera de la même taille que ta carte SD et ce quelque soit l'espace occupé. Si tu as 20 Go d'utilisés sur une carte de 128 Go ton fichier image fera 128 Go et sera essentiellement composé d'espace vide!
Bien sûr tu peux compresser le fichier en ZIP, tu vas gagner de la place mais c'est long, peu pratique et il te faudra de la place pour faire ça.

La méthode que je vais t'expliquer consiste à réduire la taille de la partition à l'intérieur du fichier image et ce sans avoir besoin d'espace disque supplémentaire. Ceci permet aussi de copier une carte sur une autre de plus petite taille, bien entendu la carte devra être plus grande que ce qu'occupent les fichiers. Par exemple tu pourras copier le dump d'une carte de 128 Go où il n'y a réellement que 20 Go d'occupés sur une carte de 32 Go.

Ceci te sera également utile pour cloner une carte SD sur une autre car bien que tu aie 2 cartes SD de même capacité, du même constructeur et du même modèle, leur capacité peut être différente de quelques octets. Si ta carte a des octets en plus par rapport à ton fichier image ça ne posera pas de problème, en revanche si ce sont des octets en moins tu risques d'avoir des problèmes.

Ton image de carte SD comporte 2 partitions, une au format FAT32 de petite taille servant au boot et que l'on ne va pas toucher, et une autre au format EXT4 que l'on va redimensionner.

Dans un premier temps j'explique en détails la méthode manuelle puis à la fin tu trouveras un script shell bash permettant d'automatiser la réduction du fichier image.

Attention!
On modifie directement le fichier image, si tu as peur de faire une fausse manip fais une copie du fichier image.

Ce tuto a été fait avec l'utilisateur root.

Méthode manuelle avec les explications détaillés

Montage de l'image

On va monter le fichier image comme un disque virtuel.

Vérifie qu'un périphérique /dev/loopX est libre où X est un numéro, par exemple /dev/loop0. 

losetup

Soit la commande ne renvoie rien, ce qui signifie qu'aucun périphérique n'est utilisé, soit elle renvoie la liste des périphériques utilisés. Dans ce cas prends un numéro non utilisé.

On monte l'image comme un disque virtuel.
Dans l'exemple on monte le fichier imageCarteSD.img sur le périphérique /dev/loop0.

losetup /dev/loop0 imageCarteSD.img

On dit au système de recharger la table des partitions du périphérique /dev/loop0

partprobe /dev/loop0

Liste les partitions du disque virtuel /dev/loop0

lsblk /dev/loop0

Tu obtiens un résultat de ce genre.
Les partitions ont pour nom le périphérique, loop0 dans cet exemple suivi de la lette p pour partition suivi du numéro de la partition, 1 ou 2 dans cet exemple. La partition qui nous intéresse est la plus grosse, loop0p2. 

NAME      MAJ:MIN RM  SIZE RO TYPE MOUNTPOINT
loop0       7:0    0 59,5G  0 loop
├─loop0p1 259:0    0  256M  0 part
└─loop0p2 259:1    0 59,2G  0 part

Vérification du filesystem

Vérifier la partition N°2, /dev/loop0p2 qui est celle que l'on va redimensionner

e2fsck -f /dev/loop0p2

Exemple de résultat

e2fsck 1.46.2 (28-Feb-2021)
Pass 1: Checking inodes, blocks, and sizes
Pass 2: Checking directory structure
Pass 3: Checking directory connectivity
Pass 4: Checking reference counts
Pass 5: Checking group summary information
rootfs: 309168/3837504 files (0.4% non-contiguous), 5842781/15525376 blocks

Redimensionnement du filesystem

On passe à l'étape du redimensionnent du système de fichiers, l'option -M indique de minimiser le filesystem le plus possible (uniquement l'espace occupé)

resize2fs -p /dev/loop0p2 -M

Maintenant, tu n'a plus qu'à patienter c'est l'étape la plus longue, la durée de cette étape dépend de la taille du fichier image et des performances de ton matériel. Des X s'affichent pour montrer la progression

resize2fs 1.46.2 (28-Feb-2021)
Resizing the filesystem on /dev/loop0p2 to 6032828 (4k) blocks.
Begin pass 2 (max = 4001911)
Relocating blocks             XXXXXXXX--------------------------------

Voilà le résultat obtenu quand la commande s'est terminée

resize2fs 1.46.2 (28-Feb-2021)
Resizing the filesystem on /dev/loop0p2 to 6032828 (4k) blocks.
Begin pass 2 (max = 4001911)
Relocating blocks             XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
Begin pass 3 (max = 474)
Scanning inode table          XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
Begin pass 4 (max = 41009)
Updating inode references     XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
The filesystem on /dev/loop0p2 is now 6032828 (4k) blocks long.

Redimensionnement de la partition

On récupère le nombre de blocs occupés par le filesystem et leur taille. La commande retournant pas mal d'infos, le grep permet de filtrer la sortie avec seulement ce qui nous intéresse.

dumpe2fs -h /dev/loop0p2 | grep "Block count\|Block size"

Résultat

dumpe2fs 1.46.2 (28-Feb-2021)
Block count:              6032828
Block size:               4096

On regarde la taille des blocs de notre fichier image

fdisk -l imageCarteSD.img | grep Units

Résultat

Units: sectors of 1 * 512 = 512 bytes

Les blocs de notre fichier image font 512 octets.

Il faut calculer où se termine la partition en nombre de blocs de 512 octets grâce à ce calcul:

(Block count × Block size) / Units + 1 = fin de la partition

Par sécurité on ajoute 1 bloc d'où le “+ 1” dans le calcul.

Dans notre exemple

(6032828 × 4096) / 512 + 1 = 48262625

Astuce pour faire directement le calcul dans la ligne de commande

echo $(((6032828 * 4096) / 512 + 1))

On redimensionne la partition avec fdisk

fdisk /dev/loop0

Tu arrives dans le shell interactif de fdisk. Rien n'est modifié tant que tu n'a pas écris les modifications avec w.

Affiche la table des partitions avec l'option p, et retiens la valeur du “Start” (532480)  de la partition N°2 /dev/loop0p2 

Command (m for help): p
Disk /dev/loop0: 59,48 GiB, 63864569856 bytes, 124735488 sectors
Units: sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disklabel type: dos
Disk identifier: 0xfccf3316

Device       Boot  Start       End   Sectors  Size Id Type
/dev/loop0p1        8192    532479    524288  256M  c W95 FAT32 (LBA)
/dev/loop0p2      532480 124735487 124203008 59,2G 83 Linux

Command (m for help):

Supprime la partition N°2 avec d et 2. L'opération peut faire peur mais on ne supprime pas les données, seulement la partition.

Command (m for help): d
Partition number (1,2, default 2): 2

Partition 2 has been deleted.

Command (m for help):

Crée une nouvelle partition avec les commandes n, p, 2.

First sector: valeur “Start” de la seconde partition relevée précédemment ⇒ 532480.
Last sector: valeur calculée de la fin de la partition avec un “+” devant ⇒ +48262625
À la question “Do you want to remove the signature?” réponds non, choix n

Command (m for help): n
Partition type
   p   primary (1 primary, 0 extended, 3 free)
   e   extended (container for logical partitions)
Select (default p): p
Partition number (2-4, default 2): 2
First sector (2048-124735487, default 2048): 532480
Last sector, +/-sectors or +/-size{K,M,G,T,P} (532480-124735487, default 124735487): +48262625

Created a new partition 2 of type 'Linux' and of size 23 GiB.
Partition #2 contains a ext4 signature.

Do you want to remove the signature? [Y]es/[N]o: n

Command (m for help):

Affiche le nouveau partitionnement avec p

Command (m for help): p

Disk /dev/loop0: 59,48 GiB, 63864569856 bytes, 124735488 sectors
Units: sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disklabel type: dos
Disk identifier: 0xfccf3316

Device       Boot  Start      End  Sectors  Size Id Type
/dev/loop0p1        8192   532479   524288  256M  c W95 FAT32 (LBA)
/dev/loop0p2      532480 48795105 48262626   23G 83 Linux

Command (m for help):

Tu remarqueras que la seconde partition /dev/loop0p2 a réduite en taille.
Gardes en mémoire la valeur de “End ” (48795105) de la dernière partition, /dev/loop0p2 tu en auras besoin pour la suite.

Enregistre les modifications avec w.
Ignore le message d'erreur “Re-reading the partition table failed.: Argument invalide”

Command (m for help): w
The partition table has been altered.
Calling ioctl() to re-read partition table.
Re-reading the partition table failed.: Argument invalide

The kernel still uses the old table. The new table will be used at the next reboot or after you run partprobe(8) or partx(8).

Redimensionnement du fichier image

Détache le disque virtuel

losetup -d /dev/loop0

Redimensionne le fichier image.

Il faut calculer la nouvelle taille du fichier pour dire où le tronquer

(fin dernière partition + 1) × taille bloc = taille du fichier

On ajoute 1 bloc par sécurité d'où le “+ 1” dans le calcul
Pour rappel la taille des blocs de notre fichier image c'est 512 octets, donnés par la commande fdisk -l

(48795105 + 1) × 512 = 24983094272

Pour faire le calcul dans la ligne de commande

echo $(((48795105 + 1) * 512))

Tronque le fichier à la taille calculée précédemment

truncate -s 24983094272 imageCarteSD.img

C'est terminé!

Tu peux constater avec la commande ls que ton fichier a diminué de taille.

Pour vérifier tu peux monter l'image comme décrit dans ce post.

Script shell

Télécharge le script: rpiShrink.sh

Ce script a été testé sur un Raspberry Pi mais ça devrait fonctionner sur tout autre Linux. Ce script automatise entièrement la procédure et fait la même chose que les paragraphes précédents.

Il prends comme unique argument le fichier image à réduire. Exemple de sortie plus loin dans l'article.

./rpiShrink.sh <FICHIER_IMAGE>

Le contenu du script

#!/bin/bash

#
# Fichier image
#
# Vérification des arguments
if [ -z "$1" ]
    then
    echo
    echo -e "\033[38;2;255;0;0;1m[ERREUR] Indiquer le fichier image à redimentionner\e[0m"
    echo
    exit 1
fi
imageFile=$1

#
# Demande de confirmation
#
echo -e "\033[38;2;255;0;0;1mATTENTION! ce script est fait pour redimentionner les images de cartes SD de Raspberry Pi utilisant Raspberry Pi OS. L'utilisation de ce script pour un autre utilisation risque de produire des résultats inattendus.\e[0m"
echo -e "\033[38;2;255;0;0;1mPour plus de détails et l'explication du script, voir ici: https://www.jesus-forain.fr/blog/reduire-la-taille-d-une-image-de-carte-sd-d-un-raspberry-pi-136.html\e[0m"
echo
echo -e "\033[38;2;255;0;0;1mLe fichier image donné en argument sera modifié, il est conseillé de faire une copie de sauvegarde de ce fichier image\e[0m"
echo
echo -e "Fichier à réduire: \033[38;2;0;255;255;1m$imageFile\e[0m"
echo -n "Confirmer (O/N)? "
read confirm
confirm=$(echo $confirm | tr '[:upper:]' '[:lower:]')
if [ $confirm != o ]; then
    exit 0
fi

#
# Recherche d'un périphérique loop libre
#
echo -e "\033[38;2;0;255;255;1m[INFO] Recherche d'un périphérique /dev/loopX libre\e[0m"
loopNb=0
nbLoopDevices=$(ls -l /dev | grep -e "loop[0-9]\+" | wc -l)
echo -e "$nbLoopDevices périphériques /dev/loopX disponibles"
losetup | grep /dev/loop$loopNb > /dev/null
while (( $? == 0 )); do
    echo "/dev/loop$loopNb est utilisé"
    loopNb=$(($loopNb + 1))

    # Plus de loopX disponible
    if (($loopNb >= $nbLoopDevices)); then
        echo -e "\033[38;2;255;0;0;1m[ERREUR] aucun périphérique /dev/loopX libre\e[0m"
        exit 1
    fi
    losetup | grep /dev/loop$loopNb > /dev/null
done

echo -e "\033[38;2;0;255;255;1m[INFO] /dev/loop$loopNb est libre\e[0m"

#
# Montage de l'image
#
echo -e "\033[38;2;0;255;255;1m[INFO] Montage de l'image\e[0m"
losetup /dev/loop$loopNb $imageFile
if (( $? != 0 )); then
    echo -e "\033[38;2;255;0;0;1m[ERREUR] échec du montage de l'image\e[0m"
    exit 1
fi

#
# Rechargement de la table des partitions
#
echo -e "\033[38;2;0;255;255;1m[INFO] Rechargement de la table des partitions\e[0m"
partprobe /dev/loop$loopNb
if (( $? != 0 )); then
    echo -e "\033[38;2;255;0;0;1m[ERREUR] échec du rechargement de la table des partitione\e[0m"
    exit 1
fi

# Affichage de la structure des partitions
echo -e "\033[38;2;0;255;255;1m[INFO] affichage de la structure des partitions\e[0m"
lsblk /dev/loop$loopNb

#
# Vérification du filesystem
#
echo -e "\033[38;2;0;255;255;1m[INFO] Vérification du filesystem\e[0m"
e2fsck -y -f /dev/loop${loopNb}p2
# Pas de vérifications du code retour car s'il y a des corrections la valeur est "faux"

#
# Redimensionnement du filesystem
#
echo -e "\033[38;2;0;255;255;1m[INFO] Redimensionnement du filesystem. Cette étape est la plus longue du script et peut durer plusieurs dizaines de minutes selon la taille du fichier image\e[0m"
resize2fs -p /dev/loop${loopNb}p2 -M
if (( $? != 0 )); then
    echo -e "\033[38;2;255;0;0;1m[ERREUR] échec du redimensionnement du filesystem\e[0m"
    exit 1
fi

# Récupération d'informations sur les partitions
blockCount=$(dumpe2fs -h /dev/loop${loopNb}p2 2>/dev/null | grep "Block count" | awk '{print $3}')
blockSize=$(dumpe2fs -h /dev/loop${loopNb}p2 2>/dev/null | grep "Block size" | awk '{print $3}')
sectorsSize=$(fdisk -l $imageFile | grep Units | awk '{print $8}')

partitionStart=$(fdisk -l /dev/loop$loopNb | grep -e "/dev/loop${loopNb}p2.*Linux" | awk '{print $2}')
partitionEnd=$((($blockCount * $blockSize) / $sectorsSize + 1))

echo -e "\033[38;2;0;255;255;1m[INFO] Informations sur les partitions\e[0m"
echo "nombre de blocs   : $blockCount"
echo "taille de bloc    : $blockSize octets"
echo "taille de secteur : $sectorsSize octets"
echo "début de partition: $partitionStart"
echo "fin de partition  : ($blockCount * $blockSize) / $sectorsSize + 1) = $partitionEnd"

#
# Modification des partitions
#

echo -e "\033[38;2;0;255;255;1m[INFO] Modification des partitions\e[0m"

# Script fdisk trouvé ici:
# https://superuser.com/questions/332252/how-to-create-and-format-a-partition-using-a-bash-script
sed -e 's/\s*\([\+0-9a-zA-Z]*\).*/\1/' << EOF | fdisk /dev/loop$loopNb
    p # afficher la table des partitions
    d # menu supprimer la partition
    2 # supprimer la partition N°2
    n # menu nouvelle partition
    p # type de partition (primaire)
    2 # appliquer à la partition N°2
    $partitionStart # début de la partition
    +$partitionEnd # fin de la partition. Attention, il y a un '+' devant la taille
     # Do you want to remove the signature? [Y]es/[N]o: => non par défaut
    p # affichage du nouveau partitionnement
    w # écriture des modifications sur les partitions
    q # Quitter
EOF

# Pas de vérification de la valeur de retour car ça sera toujours faux à cause du message "Re-reading the partition table failed.: Argument invalide"

# Récupération d'infos sur la nouvelle partition
newPartitionEnd=$(fdisk -l /dev/loop$loopNb | grep -e "/dev/loop${loopNb}p2.*Linux" | awk '{print $3}')
newFileSize=$((($newPartitionEnd + 1) * $sectorsSize))

#
# Redimentionnement du fichier image
#

# Détacher la disque virtuel /dev/loopX
echo -e "\033[38;2;0;255;255;1m[INFO] Détacher la disque virtuel /dev/loop$loopNb\e[0m"
losetup -d /dev/loop$loopNb 
if (( $? != 0 )); then
    echo -e "\033[38;2;255;0;0;1m[ERREUR] échec du détachement du périphérique /dev/loop$loopNb\e[0m"
    exit 1
fi

# Réduction du fichier image
echo -e "\033[38;2;0;255;255;1m[INFO] Réduction du fichier image à $newFileSize octets\e[0m"
truncate -s $newFileSize $imageFile
if (( $? != 0 )); then
    echo -e "\033[38;2;255;0;0;1m[ERREUR] échec de la réduction du fichier image\e[0m"
    exit 1
fi

echo
echo -e "\033[38;2;0;255;0;1mTERMINÉ\e[0m"
echo

Exemple de sortie

ATTENTION! ce script est fait pour redimentionner les images de cartes SD de Raspberry Pi utilisant Raspberry Pi OS. L'utilisation de ce scri pt pour un autre utilisation risque de produire des résultats inattendus.
Pour plus de détails et l'explication du script, voir ici: https://www.jesus-forain.fr/blog/reduire-la-taille-d-une-image-de-carte-sd-d-un-raspberry-pi-136.html

Le fichier image donné en argument sera modifié, il est conseillé de faire une copie de sauvegarde de ce fichier image

Fichier à réduire: imageSD-01.img
Confirmer (O/N)? o
[INFO] Recherche d'un périphérique /dev/loopX libre
8 périphériques /dev/loopX disponibles
[INFO] /dev/loop0 est libre
[INFO] Montage de l'image
[INFO] Rechargement de la table des partitions
[INFO] affichage de la structure des partitions
NAME      MAJ:MIN RM   SIZE RO TYPE MOUNTPOINT
loop0       7:0    0 119,1G  0 loop
├─loop0p1 259:0    0   256M  0 part
└─loop0p2 259:1    0 118,8G  0 part
[INFO] Vérification du filesystem
e2fsck 1.46.2 (28-Feb-2021)
Pass 1: Checking inodes, blocks, and sizes
Inodes that were part of a corrupted orphan linked list found.  Fix? yes

Inode 46420 was part of the orphaned inode list.  FIXED.
Pass 2: Checking directory structure
Pass 3: Checking directory connectivity
Pass 4: Checking reference counts
Pass 5: Checking group summary information

rootfs: ***** FILE SYSTEM WAS MODIFIED *****
rootfs: 827194/7699296 files (0.5% non-contiguous), 23422146/31150592 blocks
[INFO] Redimensionnement du filesystem. Cette étape est la plus longue du script et peut durer plusieurs dizaines de minutes selon la taille du fichier image
resize2fs 1.46.2 (28-Feb-2021)
Resizing the filesystem on /dev/loop0p2 to 23674536 (4k) blocks.
Begin pass 2 (max = 3472201)
Relocating blocks             XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
Begin pass 3 (max = 951)
Scanning inode table          XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
Begin pass 4 (max = 44596)
Updating inode references     XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
The filesystem on /dev/loop0p2 is now 23674536 (4k) blocks long.

[INFO] Informations sur les partitions
nombre de blocs   : 23674536
taille de bloc    : 4096 octets
taille de secteur : 512 octets
début de partition: 532480
fin de partition  : (23674536 * 4096) / 512 + 1) = 189396289
[INFO] Modification des partitions

Welcome to fdisk (util-linux 2.36.1).
Changes will remain in memory only, until you decide to write them.
Be careful before using the write command.


Command (m for help): Disk /dev/loop0: 119,08 GiB, 127865454592 bytes, 249737216 sectors
Units: sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disklabel type: dos
Disk identifier: 0x9032c265

Device       Boot  Start       End   Sectors   Size Id Type
/dev/loop0p1        8192    532479    524288   256M  c W95 FAT32 (LBA)
/dev/loop0p2      532480 249737215 249204736 118,8G 83 Linux

Command (m for help): Partition number (1,2, default 2):
Partition 2 has been deleted.

Command (m for help): Partition type
   p   primary (1 primary, 0 extended, 3 free)
   e   extended (container for logical partitions)
Select (default p): Partition number (2-4, default 2): First sector (2048-249737215, default 2048): Last sector, +/-sectors or +/-size{K,M,G,T,P} (532480-249737215, default 249737215):
Created a new partition 2 of type 'Linux' and of size 90,3 GiB.
Partition #2 contains a ext4 signature.

Command (m for help):

Command (m for help):
Disk /dev/loop0: 119,08 GiB, 127865454592 bytes, 249737216 sectors
Units: sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disklabel type: dos
Disk identifier: 0x9032c265

Device       Boot  Start       End   Sectors  Size Id Type
/dev/loop0p1        8192    532479    524288  256M  c W95 FAT32 (LBA)
/dev/loop0p2      532480 189928769 189396290 90,3G 83 Linux

Command (m for help): The partition table has been altered.
Calling ioctl() to re-read partition table.
Re-reading the partition table failed.: Argument invalide

The kernel still uses the old table. The new table will be used at the next reboot or after you run partprobe(8) or partx(8).

[INFO] Détacher la disque virtuel /dev/loop0
[INFO] Réduction du fichier image à 97243530240 octets

TERMINÉ