Copiez l'installation Raspbian existante sur une carte SD plus petite

Est-il possible de copier une installation Raspbian existante et configurée sur une carte SD plus petite?

Lorsque j'ai installé Raspbian pour la première fois, je n'avais qu'une carte de 32 Go à portée de main, ce qui est évidemment plus gros que nécessaire.

Dans cette réponse, je montre ce qu'il faut faire étape par étape pour que les gens comprennent la logique derrière la solution et soient capables d'appliquer des étapes à leurs autres problèmes.

Mais tout d'abord, il convient de préciser qu'il s'agit d'un problème générique (non spécifique à Raspi) de migrer les systèmes de fichiers d'une carte SD vers une carte SD plus petite (mais suffisamment grande pour les données).

Exigences

Un ordinateur portable avec un lecteur de carte micro SD et Linux (je préfère Ubuntu) fonctionnant dessus.

Abréviations

PIBOX      : Raspberry Pi which is used
SD_CARD_A  : 8GB micro SD card which is used on PIBOX and on which Raspbian-lite (the OS) is installed
SD_CARD_B  : 2GB micro SD card which will be used on PIBOX and on which Raspbian-lite (the OS) will be installed

Partitions de SD_CARD_A

Pendant que PIBOX fonctionne, nous listons les partitions (les partitions système inutiles ne sont pas affichées ici).

root@pibox:~# df -Th
Filesystem     Type      Size  Used Avail Use% Mounted on
/dev/root      ext4      7.3G  1.1G  5.9G  16% /
/dev/mmcblk0p1 vfat       63M   21M   43M  33% /boot

Il y a 2 partitions sur SD_CARD_A comme /et /boot. Même 2 Go ne sont pas utilisés au total.

Sauvegarde SD_CARD_A

Après avoir arrêté et arrêté PIBOX, nous retirons SD_CARD_A de la carte PIBOX et le mettons dans le lecteur de carte de notre ordinateur portable.

Les partitions de SD_CARD_A sont automatiquement montées sur notre système au fur /dev/sdc1et à mesure /dev/sdc2.

root@mylaptop:~# df -Th
Filesystem                    Type      Size  Used Avail Use% Mounted on
/dev/sdb2                     ext4       22G   13G  7.9G  63% /
/dev/sdb1                     vfat      197M  2.6M  195M   2% /boot/efi
/dev/sda8                     ext4       66G   11G   52G  17% /home
/dev/sdc1                     vfat       63M   21M   43M  33% /media/some_user_name/boot
/dev/sdc2                     ext4      7.3G  1.1G  5.9G  16% /media/some_user_name/some_uuid_serial

Nous démontons ces partitions de notre système pour qu'elles fonctionnent correctement.

root@mylaptop:~# umount /dev/sdc1
root@mylaptop:~# umount /dev/sdc2

Nous affichons les informations sur l'appareil de SD_CARD_A en détail pour les confirmations dans les prochaines étapes.

root@mylaptop:~# fdisk -l /dev/sdc
Disk /dev/sdc: 7969 MB, 7969177600 bytes
246 heads, 62 sectors/track, 1020 cylinders, total 15564800 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
Disk identifier: 0x2019f6d8

   Device Boot      Start         End      Blocks   Id  System
/dev/sdc1            8192      137215       64512    c  W95 FAT32 (LBA)
/dev/sdc2          137216    15564799     7713792   83  Linux

Ci-dessus, vous pouvez voir que SD_CARD_A a une capacité de 8 Go.

Nous clonons SD_CARD_A dans le fichier pibox.img.

root@mylaptop:~# dd bs=4MB if=/dev/sdc of=pibox.img
1992+1 records in
1992+1 records out
7969177600 bytes (8.0 GB) copied, 416.582 s, 19.1 MB/s

Vérifiez la taille des octets copiés, elle est égale à la valeur que nous avons obtenue par fdisk -l /dev/sdccommande.

Module de bouclage Linux

Linux a un module appelé loopback qui nous permet de gérer un fichier comme un périphérique bloc.

Nous chargeons le module de bouclage.

root@mylaptop:~# modprobe loop

Nous trouvons un chemin de périphérique de bouclage inutilisé.

root@mylaptop:~# losetup -f /dev/loop0

Maintenant, nous créons un périphérique de bouclage pour le fichier pibox.img.

root@mylaptop:~# losetup /dev/loop0 pibox.img

Nous déclenchons le noyau sur les changements de partition.

root@mylaptop:~# partprobe /dev/loop0

Nous confirmons si les opérations précédentes ont réussi.

root@mylaptop:~# losetup /dev/loop0
/dev/loop0: [0806]:69 (/root/pibox.img)

Nous affichons les informations du périphérique de bouclage en détail pour le comparer avec SD_CARD_A.

root@mylaptop:~# fdisk -l /dev/loop0
Disk /dev/loop0: 7969 MB, 7969177600 bytes
255 heads, 63 sectors/track, 968 cylinders, total 15564800 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
Disk identifier: 0x2019f6d8

      Device Boot      Start         End      Blocks   Id  System
/dev/loop0p1            8192      137215       64512    c  W95 FAT32 (LBA)
/dev/loop0p2          137216    15564799     7713792   83  Linux

Ci-dessus, vous pouvez voir que la taille du périphérique de bouclage (= 7969177600 octets) et les partitions sont identiques à celles de SD_CARD_A.

Mathématiques de base

Désormais, nous nous concentrerons sur la partition /dev/loop0p2. Appelons-le THE_PARTITION .

La taille du bloc est de 512 octets (comme imprimé sur la ligne commençant par Unités = secteurs .....)

THE_PARTITION commence à partir du bloc 137216 et se termine au bloc 15564799 ce qui signifie qu'il a la taille de 15427584 blocks(= 15564799 - 137216 + 1).

Ainsi, la taille de THE_PARTITION en octets est 7898923008 bytes(= 512 * 15427584).

Pour adapter THE_PARTITION dans SD_CARD_B, nous voulons qu'il ait une nouvelle taille 3710940 blocks ou en d'autres termes 1900001280 bytes(= 512 * 3710940).

Ainsi, le nouveau numéro de bloc de fin est 3848155calculé par start block number(= 137216) + size in blocks(= 3710940) - 1.

Système de fichiers vs partition

Il y a 2 opérations qui ne doivent pas être confondues.

• Redimensionnement du système de fichiers. Nous allons réduire le système de fichiers sur THE_PARTITION en définissant sa taille sur 3710940 blocks.
• Redimensionnement de la partition. Nous allons réduire THE_PARTITION en définissant son numéro de bloc de fin sur 3848155.

Rétrécissement du système de fichiers

Avant de réduire le système de fichiers, il doit être marqué comme propre par e2fsck.

root@mylaptop:~# e2fsck -f /dev/loop0p2
e2fsck 1.42.9 (4-Feb-2014)
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
/dev/loop0p2: 41175/475776 files (0.2% non-contiguous), 309183/1928448 blocks

Nous réduisons le système de fichiers avec resize2fs.

root@mylaptop:~# resize2fs /dev/loop0p2 3710940s
resize2fs 1.42.9 (4-Feb-2014)
Resizing the filesystem on /dev/loop0p2 to 463867 (4k) blocks.
The filesystem on /dev/loop0p2 is now 463867 blocks long.

Rétrécissement de la partition

Nous apprenons avec quel numéro THE_PARTITION parted.

root@mylaptop:~# parted /dev/loop0
GNU Parted 2.3
Using /dev/loop0
Welcome to GNU Parted! Type 'help' to view a list of commands.
(parted) print                                                            
Model: Loopback device (loop)
Disk /dev/loop0: 7969MB
Sector size (logical/physical): 512B/512B
Partition Table: msdos

Number  Start   End     Size    Type     File system  Flags
 1      4194kB  70.3MB  66.1MB  primary  fat16        lba
 2      70.3MB  7969MB  7899MB  primary  ext4

(parted) quit

Nous réduisons THE_PARTITION avec parted.

root@mylaptop:~# parted /dev/loop0 unit s resizepart 2 3848155
Warning: Shrinking a partition can cause data loss, are you sure you want to continue?
Yes/No? Yes  

Nous avons terminé avec le périphérique de bouclage. On le détache.

root@mylaptop:~# losetup -d /dev/loop0

Fichier d'image tronquée

Nous vérifions la nouvelle table de partition.

root@mylaptop:~# fdisk -l pibox.img 

Disk pibox.img: 7969 MB, 7969177600 bytes
255 heads, 63 sectors/track, 968 cylinders, total 15564800 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
Disk identifier: 0x2019f6d8

    Device Boot      Start         End      Blocks   Id  System
pibox.img1            8192      137215       64512    c  W95 FAT32 (LBA)
pibox.img2          137216     3848155     1855470   83  Linux

Dans la sortie, on voit clairement que le nombre de bloc de fin de THE_PARTITION est diminué from 15564799 to 3848155.

Le dernier bloc que nous utilisons est 3848155. La numérotation des blocs commence à 0. Nous avons donc 3848155 + 1 blocs au total et la nouvelle taille du fichier pibox.img devrait être 1970255872 bytes (= (3848155 + 1) * 512).

Nous tronquons le fichier pibox.img.

root@mylaptop:~# truncate --size=1970255872 pibox.img

Nous vérifions la nouvelle taille du fichier pibox.img.

root@mylaptop:~# ls -l pibox.img 
-rw-r--r-- 1 root root 1970255872 Oct 13 21:53 pibox.img

Création de SD_CARD_B

Nous avons mis SD_CARD_B dans le lecteur de carte de notre ordinateur portable. Les partitions de SD_CARD_B sont automatiquement montées sur notre système au fur /dev/sdc1et à mesure /dev/sdc2.

root@mylaptop:~# df -Th
Filesystem                    Type      Size  Used Avail Use% Mounted on
/dev/sdb2                     ext4       22G   13G  7.9G  63% /
/dev/sdb1                     vfat      197M  2.6M  195M   2% /boot/efi
/dev/sda8                     ext4       66G   11G   52G  17% /home
/dev/sdc1                     vfat       63M   21M   43M  33% /media/some_user_name/boot
/dev/sdc2                     ext4      1.8G  1.6G   59M  97% /media/some_user_name/some_uuid_serial

Ci-dessus, vous pouvez voir que SD_CARD_B a une capacité de 2 Go.

Nous démontons ces partitions de notre système pour fonctionner avec succès sur SD_CARD_B.

root@mylaptop:~# umount /dev/sdc1
root@mylaptop:~# umount /dev/sdc2

Nous clonons le fichier pibox.img dans SD_CARD_B.

root@mylaptop:~# dd bs=4MB if=pibox.img of=/dev/sdc
492+1 records in
492+1 records out
1970255872 bytes (2.0 GB) copied, 646.967 s, 3.0 MB/s

Vérifiez la taille des octets copiés, elle est égale à la valeur que nous avons obtenue par ls -l pibox.imgcommande.

Démarrage de PIBOX

Après avoir retiré SD_CARD_B de notre ordinateur portable et l'avoir placé dans la carte PIBOX, nous démarrons le système et nous connectons à la console PIBOX.

Nous listons les partitions (certaines autres partitions système inutiles ne sont pas affichées ici).

root@pibox:~# df -Th
Filesystem     Type      Size  Used Avail Use% Mounted on
/dev/root      ext4      1.8G  1.1G  601M  64% /
/dev/mmcblk0p1 vfat       63M   21M   43M  33% /boot

Lorsque vous l'utilisez dd if=/dev/sdx of=/path/to/image bs=1M, se /dev/sdxréfère à l'ensemble du "disque", donc l'image aurait toujours la taille de la carte entière.

Au lieu de cela, vous devez utiliser l' dd if=/dev/sdxn ...emplacement ndu numéro de partition.

Vous devrez probablement le faire deux fois - une fois pour la /bootpartition et une fois pour la /partition.

Ensuite, vous devez créer des partitions sur la nouvelle carte qui sont au moins aussi grandes que ces deux originales, pour réenregistrer le contenu.

Utilisez quelque chose comme parted (éditeur de partition) pour réduire la partition principale à une taille plus petite, puis utilisez un outil comme Clonezilla pour copier de la partition désormais plus petite vers votre nouvelle carte. Cependant, vous devrez probablement le faire sur un autre ordinateur.

1. Créer une image de la carte en utilisant l'une des méthodes déjà mentionnées - Comment sauvegarder mon Raspberry Pi?

2. Utilisez le script à http://sirlagz.net/2013/03/10/script-automatic-rpi-image-downsizer/ pour réduire l'image

3. Restaurer l'image réduite sur une nouvelle carte plus petite

J'utilise rsyncpour copier des systèmes de fichiers d'un disque à un autre depuis un certain temps maintenant, sans hoquet. L'avantage d'utiliser rsync est qu'il copie le contenu du système de fichiers, plutôt que de faire une copie au niveau bloc de l'appareil; par conséquent, peu importe la taille des lecteurs cible et source, tant que le lecteur cible dispose de suffisamment d'espace pour contenir les données.

Voici donc comment je le ferais:

1. Créez une nouvelle installation Raspbian sur la nouvelle carte SD que vous souhaitez, plus petite.
2. Démarrez dans la nouvelle installation et développez le système de fichiers pour remplir tout le disque. Arrêtez le pi.
3. Montez maintenant les nouvelles et anciennes cartes et utilisez rsync -avx oldFilesystem newFilesystempour copier / écraser le système de fichiers sur la nouvelle carte avec le système de fichiers de l'ancienne carte.
4. Enfin, démarrez votre nouveau système et exécutez rpi-updatepour vous assurer que votre micrologiciel est cohérent et à jour.

Après cela, votre nouvelle carte devrait avoir un système Raspbian parfaitement fonctionnel installé dessus.

J'ai créé un script shell pour sauvegarder et restaurer toutes les données sur une carte SD. Il supprime d'abord certaines données (correspondant à mon projet) et réduit la partition à la taille minimale afin que l'image soit aussi grande que les données sur la carte SD. En complément, le script crée un fichier * .zip de l'image. Après avoir restauré l'image créée sur une autre carte SD, la partition sera agrandie à sa taille maximale. Le script utilise les commandes mentionnées dans les autres réponses. Comme c'est mon premier script shell avec cette taille, il m'a fallu des heures pour le créer et ce n'est pas un jet parfait. Surtout, je ne sais pas comment gérer les valeurs de retour de resize2fs et fdisk donc l'utilisateur doit taper les valeurs dont j'ai besoin. Y a-t-il des idées pour y remédier? J'espère que ce script aide quelqu'un d'autre. N'hésitez pas à le modifier et à l'améliorer.

"Usage:
    <skriptname> -b <path>                  create backup of SC Card (dev/mmcblk0) to file <path>/JJJJ-MM-DD_HHMM.img
    <skriptname> -r <path>/FILENAME.img     restore an exitsting image (<path>/FILENAME.img) to the SD Card (dev/mmcblk0) 
    <skriptname> -r <path>/FILENAME.zip     unzip and restore an exitsting image (<path>/FILENAME.zip) to the SD Card (dev/mmcblk0)
    <skriptname> -h                         show this hlep

C'est ici:

#!/bin/bash 

# check if the user is root
if (( $EUID != 0 )); then
  echo "This script requires root privileges please run as root"
  exit
fi


while getopts ":b:r:h" opt; do
  case $opt in
    b)
      mode="backup"
      OUTPATH=$OPTARG
      ;;
    r)
      mode="restore"
      DIRFILENAME=$OPTARG
      ;;
    h)
      mode="help"
      ;;
    \?)
      echo "Invalid option: -$OPTARG. Use -h for help" >&2
      exit 1
      ;;
    :)
      echo "Option -$OPTARG requires an argument. Use -h for help" >&2
      exit 1
      ;;
  esac
done
# no option
if [ $OPTIND == 1 ]
then
  echo "$(basename "$0") needs an option! Use -h for help"
  exit 1
fi


myMount(){
  # create mountpoint if not existing
  if [ ! -d /tmp/sd2/ ] ; then
    mkdir /tmp/sd2
  fi

  # mount partition
  mount -v -t ext4 /dev/mmcblk0p2 /tmp/sd2
  err=$?
  if [ $err != 0 ]; then
    echo "mount failed error: $err"
    exit 1
  fi
}

myUmount(){
  cd /home/ # otherwise umount will fail
  # fuser -vm /tmp/sd2/

  # umount partition
  umount -v /tmp/sd2
  err=$?
  if [ $err != 0 ]; then
    echo "umount failed error: $err"
    exit 1
  fi
}

myEnlarge(){
  echo "enlarge partition..."
  # enlarge partition is not posible with fdisk -> delete and recreate it
  (
  echo d # delete partition
  echo 2 # patition number
  echo n # add a new partition
  echo p # primary partition
  echo 2 # partition number
  echo   # first sector (accept default: varies)
  echo   # last sector (accept default: varies)
  echo w # write changes
  ) | fdisk /dev/mmcblk0

  echo "\n check filesystem... "
  e2fsck -f -v -C 0 /dev/mmcblk0p2

  # enlarge filesystem to maxsize
  resize2fs -p /dev/mmcblk0p2
}

case "$mode" in
"help")
  echo "Usage:
    $(basename "$0") -b <path>                  create backup of SC Card (dev/mmcblk0) to file <path>/JJJJ-MM-DD_HHMM.img
    $(basename "$0") -r <path>/FILENAME.img     restore an exitsting image (<path>/FILENAME.img) to the SD Card (dev/mmcblk0) 
    $(basename "$0") -r <path>/FILENAME.zip     unzip and restore an exitsting image (<path>/FILENAME.zip) to the SD Card (dev/mmcblk0)
    $(basename "$0") -h                         show this hlep
--------------------------------
Adrian Zeitler, Germany 2017"
  ;;
"backup")  ####################################### backup ####################################### 
  echo "an image of the SD Card (/dev/mmcblk0) whitch is as smal as possible will be created to $OUTPATH."
  # ------------------  delete some data --------------------

  echo "Do you want to delete tempfiles? [y/n]" 
  read delfiles

  if [ "$delfiles" = "y" ]
    then
      echo "Delete tempfiles..."

      myMount

      # remove some data
      cd /tmp/sd2/home/alarm/
      rm -v -f hagelbeere.db
      rm -v -f HAILcam.log
      rm -v -f HAILcam.log.1
      rm -v -f test.jpg

      myUmount

    elif [ "$delfiles" = "n" ]
      then
    echo "I don't delete anything."
    else
    echo "Sorry, I didn't understand."
    exit 1
  fi


  # --------------------------------------------------------------
  # shrink partition 2 to minimum size

  echo "check file system... "
  e2fsck -f -v -C 0 /dev/mmcblk0p2
  err=$?
  if [ $err != 0 ]; then
    echo "file system check failed, error: $err"
    exit 1
  fi

  echo "shrink filesystem of partition 2 to minimum size..."
  resize2fs -p -M /dev/mmcblk0p2
  err=$?
  if [ $err != 0 ]; then
    echo "resize2fs failed, error: $err"
    exit 1
  fi
  # --> Das Dateisystem auf /dev/mmcblk0p2 ist nun 692365 Blöcke groß.

  echo "Please tell me the new filesystem size displayed above:"
  read size
  # from resize2fs blocksize, fdisk wants sector: sector = block * 8
  size=$(( $size*8 ))

  # shrink partition is not posible with fdisk -> delete and recreate it
  (
  echo d # delete partition
  echo 2 # patition number
  echo n # add a new partition
  echo p # primary partition
  echo 2 # partition number
  echo   # first sector (accept default: varies)
  echo +$size  # last sector
  echo w # write changes
  ) | fdisk /dev/mmcblk0
  err=$?
  if [ $err != 0 ]; then
    echo "fdisk failed, error: $err"
    exit 1
  fi


  # --------------------------------------------------------------

  # fill unused space with zeros
  echo "Do you want to fill unused space with zeros? [y/n]" 
  read fillzeros


  if [ "$fillzeros" = "y" ]
    then
      echo "Copy zeros. This will end up with an error. But this is ok."

      myMount    

      dd if=/dev/zero | pv | dd of=/tmp/sd2/nullen.datei conv=noerror,notrunc,sync bs=10240
      # exits with error -> this is normal

      # dlelete zeros
      rm -v -f /tmp/sd2/nullen.datei
      sync

      myUmount

    elif [ "$fillzeros" = "n" ]
      then
    echo "I don't delete anything."
    else
    echo "Sorry, I didn't understand."
    exit 1
  fi

  # --------------------------------------------------------------

  # find out end of partition
  fdisk -l /dev/mmcblk0
  echo "Please tell me the end of mmcblk0p2 displayed above."
  read count



  DATE=$(date +"%Y-%m-%d_%H%M")
  IMGFILENAME=$DATE.img 
  echo "Do you want to create image with filename $OUTPATH$IMGFILENAME? [y/n]"
  read answer
  if [ "$answer" = "y" ]
  then
    echo "Do you want to create a *.zip file of the created image? [y/n]"
    read zip
    echo "Do you want to enlarge partition 2 to maxsize after image creation? [y/n]"
    read enlarge

    echo "create image..."
    cd $OUTPATH
    # create image with dd, stop at and of partition
    # count=N   copy only N input blocks
    # bs=BYTES  read and write up to BYTES bytes at a time = block size
    # pv    show status
    dd if=/dev/mmcblk0 | pv -s $(( $count*512 )) | dd of=$IMGFILENAME bs=512 count=$count
    err=$?
    if [ $err != 0 ]; then
      echo "dd failed error: $err"
      exit 1
    fi

    # --------------------------------------------------------------
    # create zip file
    # or like this:
    # sudo dd if=/dev/sdX | pv |gzip > /pfad/zur/datei.img.gz
    if [ "$zip" = "y" ]
    then
      echo "create zip file..."
      zip $DATE.zip $IMGFILENAME
    fi
    # --------------------------------------------------------------
  fi

  # --------------------------------------------------------------
  # enlarge partition 2

  if [ "$enlarge" = "y" ]
  then
    myEnlarge
  fi

  ;; #end case mode backup
"restore")  ####################################### restore ####################################### 
  #chek if image exists
  if [[ -s "$DIRFILENAME" ]]
  then
    # check if file is an image or zip file
    if [[ $DIRFILENAME =~ \.img$ ]]
    then
      IMGFILENAME=$(basename "$DIRFILENAME")
    elif [[ $DIRFILENAME =~ \.zip$ ]]
    then
      ZIPFILENAME=$(basename "$DIRFILENAME")
    else
      echo "Not the right file format. I accept *.img and *.zip"
      exit 1
    fi
  else
    echo "Image file does not exist."
    exit 1
  fi
  echo "the file $DIRFILENAME will be restored to the SD Card /dev/mmcblk0"

  #change to the path of the imagefile
  SOURCEPATH=$(dirname "$DIRFILENAME")
  cd $SOURCEPATH


  if [ "$ZIPFILENAME" != "" ]
  then
    echo "unzip file"
    # change file extention form zip zu img
    l=$(( ${#ZIPFILENAME}-3 ))
    IMGFILENAME="${ZIPFILENAME:0:l}img"
    unzip $ZIPFILENAME
  fi

  echo "Do you realy want to restore $SOURCEPATH/$IMGFILENAME to the SD card /dev/mmcblk0? 
  Warning: all data on the device /dev/mmcblk0 will be lost! [y/n]"
  read answer
  if [ "$answer" = "y" ]
  then
    echo "Do you want to enlarge partition 2 to maxsize after restoring? [y/n]"
    read enlarge
    echo "restore image..."
    filesize=$(wc -c <"$IMGFILENAME")
    echo "Filesize = $filesize Byte"
    dd if=$IMGFILENAME | pv -s $filesize | dd of=/dev/mmcblk0 bs=512
    err=$?
    if [ $err != 0 ]; then
      echo "dd failed error: $err"
      exit 1
    fi
  fi

  # --------------------------------------------------------------
  # enlarge partition 2
  if [ "$enlarge" = "y" ]
  then
    myEnlarge
  fi

  ;; #end case mode restore
esac

La solution la plus simple que j'ai trouvée était de faire une sauvegarde de la plus grande carte d'origine en utilisant les commandes dd décrites ci-dessus, puis de restaurer l'image sur la plus petite carte en utilisant quelque chose comme piwriter. dd peut aussi fonctionner ... pas sûr. PiWriter a renvoyé une erreur car il manquait de place, mais comme l'image ne contenait aucune donnée réelle au-delà de la taille de la carte plus petite, elle tronquait simplement des secteurs vides. Je ne sais pas quelles sont les implications de ceci ... la partition peut avoir besoin d'être vérifiée ou réparée mais je peux vérifier que cela a fonctionné lorsque je l'ai mise dans le Pi.

J'utilise une ancienne version de win32diskimager-RELEASE-0.1-r15-win32pour lire l'image, elle crée une image de 4 Go même à partir d'une carte SD de 8 Go et écrit ensuite l'image avec la dernière version de win32diskimager.

J'utilise l'ancienne version car l'ancienne ignorera toutes les erreurs.