Cette question répond à la question de savoir comment utiliser un ordinateur externe pour créer une sauvegarde de mon RPi.

Je me demande si je peux créer une image de sauvegarde de la carte SD actuellement utilisée et la copier dans un fichier sur un périphérique de stockage USB. Est-ce possible? Sinon, y a-t-il un moyen de créer une sauvegarde d'un RPi sans impliquer un autre ordinateur?

Voici une introduction à utiliser rsyncpour la sauvegarde sur le Pi. Une fois la sauvegarde initiale créée, la maintenir à jour de cette façon est beaucoup plus rapide que d'extraire constamment l'image entière. Vous pouvez le faire sur un disque dur local ou sur un réseau.

En fait, vous ne voulez pas qu'une copie complète d'un système en cours d'exécution soit sauvegardée, car certains éléments apparents dans le système de fichiers n'existent qu'au moment de l'exécution. Inclure cela dans une sauvegarde puis l'utiliser pour recréer une image ultérieurement peut créer des problèmes pour vous.

Il y a aussi d'autres exceptions. rsyncpeut accepter une liste de modèles ( glob ) à exclure, et ceux-ci peuvent être lus à partir d'un fichier. Commençons par ce qui devrait se trouver dans un tel fichier. Notez que les entrées sont de la forme /directory/*et non /directory. C’est parce que nous voulons qu’ils existent, mais nous ne voulons rien y copier.

/proc/*
/sys/*

Ceux-ci n'existent pas vraiment sur le disque. Ils constituent une interface avec le noyau, qui les crée et les maintient en mémoire . Si vous les copiez puis les recopiez dans un système et que vous l'amorcez, cela n'aura (au mieux) aucun sens, car le noyau les utilise comme points de montage pour les interfaces [Si vous voulez voir ce qui se passe lorsque vous montez une partition de système de fichiers sur un répertoire contenant des données, essayez. Cela fonctionne et ne fera aucun mal, mais ce qui était dans le répertoire est maintenant inaccessible.]

Notez qu'il est essentiel que les points de montage /syset /procexistent. Mais ils ne devraient rien contenir. Prochain:

/dev/*

Le devrépertoire n’est pas tout à fait la même chose procet syspour nos besoins. Si vous pensez que vous devez enregistrer ceci afin que vous puissiez avoir les mêmes nœuds de périphérique dans votre sauvegarde, vous vous trompez . Ne te dérange pas. Ne pas copier dev. Il y a longtemps, Linux fonctionnait de la sorte, mais ce n'est plus le cas.

/boot/*

C'est en quelque sorte un cas particulier avec la plupart (peut-être toutes) des distributions spécifiques à Pi, telles que Raspbian. C'est en fait un point de montage pour la première partition, vfat. Nous allons traiter cela séparément. Quoi que vous fassiez, ne vous inquiétez pas de l'inclure ici, car encore une fois, c'est un point de montage.

/tmp/*
/run/*

/rungénéralement pas sur le disque, c’est en mémoire. /tmpCela pourrait peut -être l'être aussi (cela épargnerait un peu d'action de la carte SD), mais dans tous les cas, comme l'indiquent leurs noms, ce ne sont pas des espaces pour stocker des données persistantes. Les applications qui les utilisent s’attendent à ce qu’elles puissent être supprimées à chaque démarrage.

/mnt/*
/media/*

Celles-ci sont importantes, en particulier si vous envisagez de sauvegarder sur un disque dur ou une clé USB et que le périphérique est inséré /mntou /media(le montage automatique utilise généralement cette dernière), car si vous n'excluez pas l'emplacement de ces périphériques dans le système de fichiers, créez une boucle en sauvegardant le contenu du lecteur sur lui-même, jusqu'à ce qu'il manque d'espace. Je pense que cela rsync pourrait être assez intelligent pour repérer quelque chose qui est idiot mais essayez d'éviter de tester les lieux.

Sur la sauvegarde actuelle: Créez un répertoire sur le disque dur, le périphérique USB, etc. montés localement, par exemple "pi_backup". Vous pouvez également sauvegarder sur un emplacement distant via ssh(voir ci-dessous) ou à l'aide d'un système de fichiers monté sur le réseau, mais cela prendra probablement un certain temps la première fois.

Si le fichier contenant la liste à exclure est /rsync-exclude.txt¹ et que votre lecteur l’est /mnt/usbhd, pour effectuer la sauvegarde proprement dite:

rsync -aHv --delete --exclude-from=/rsync-exclude.txt / /mnt/usbhd/pi_backup/

Notez qu'il y a un slash finalpi_backup/ .

Cela prendra un certain temps et produira beaucoup de résultats (si vous voulez examiner cela dans un journal, ajoutez-le > rsync.log). --deleten'a pas de sens la première fois, mais pour garder la sauvegarde à jour, utilisez-la. Cela garantit que les éléments que vous avez ultérieurement supprimés sur le Pi sont également supprimés de votre sauvegarde. Les aensembles récursivité dans les répertoires et vérifie tous les attributs de fichier correspondance. -Hest de conserver les liens durs ² , vest pour verbose c'est pourquoi vous obtenez une sortie (sinon, rsyncc'est calme). Voir man rsyncpour plus.

Il existe un raccourci par lequel vous pouvez ignorer le --exclude-fromfichier. Si vous êtes certain que tout ce que vous ne voulez pas copier ( /tmpetc.) se trouve sur des systèmes de fichiers distincts, vous pouvez simplement utiliser:

rsync -axHv --delete-during / /mnt/usbhd/pi_backup/

-xa été inséré. C'est la forme abrégée de --one-file-system, qui indique de rsyncne pas dépasser les limites du système de fichiers. Personnellement, je préfère le --exclude-from, mais par exemple, Raspbian par défaut, --one-file-systemfonctionnera bien. Vous pouvez utiliser les deux si vous voulez être -xprudent: D

Ce n'est pas une sauvegarde complète. C’est suffisant si vous n’avez rien inséré bootet que vous pouvez utiliser la sauvegarde pour restaurer le système en collant la carte sur un ordinateur et en exécutant:

rsync -av --delete-during /mnt/usbhd/pi_backup/ /mnt/sdcard_partition2/

Vous pouvez également faire cela avec une carte avec une nouvelle image dessus (en supposant que ce soit la même chose que votre image de base) bien que cela soit un peu inefficace si vous devez créer une image (car vous allez ensuite en écraser la majeure partie). Vous pouvez également connecter une autre carte SD via un adaptateur USB contenant une telle image et utiliser la méthode ci-dessus pour conserver une carte dupliquée.

Si vous avez inséré des éléments /boot(par exemple, un noyau personnalisé), /boot/config.txtvous devrez également les sauvegarder (assez simple - il n’ya pas grand-chose à faire). Il suffit de le faire séparément, et lors de la restauration, ces éléments sont intégrés à la première partition.

Voir ici si vous souhaitez créer une image vierge de style Raspbian dans laquelle vous pourrez ensuite effectuer une sauvegarde. Vous pouvez utiliser une méthodologie similaire pour créer une carte de style Raspbian vide. Simplement au lieu de gérer un .imgfichier, vous utiliseriez un périphérique réel (par exemple /dev/sdb), ce qui signifie que tout ce que vous avez à faire est de créer la table de partition fdisk, puis format /dev/sdb1et sdb2(ou autre) avec mkfs.

Mais copier toute l'image est plus facile! Pourquoi s'embêter avec ça?

Ce n'est pas si dur; J'ai restauré une carte vierge (formatée selon ce dernier lien) en 10 minutes. Oui, ddil est plus simple d’ utiliser l’ensemble (si vous trouvez des mots confus, par exemple ...), MAIS cela prend un certain temps à chaque fois que vous souhaitez mettre à jour votre sauvegarde, car vous devez le faire à 100% à chaque fois. Utiliser rsync, une fois qu'une sauvegarde existe, la mettre à jour est beaucoup plus rapide, vous pouvez donc l'installer sans douleur tous les jours via cron. Sur un réseau même. Toutes les six heures. Plus vous le faites souvent, moins cela prendra de temps.

rsync via ssh

Voici un exemple:

rsync [options] --rsh="ssh [ssh options]" root@[the pi ip]:/ /backup/rpi/

"Options" serait, par exemple, -av --delete --exclude-from=/rsync-exclude.txtet "options ssh" est ce que vous utilisez normalement (le cas échéant). Vous devez avoir un accès root via le sshfaire aux fins d'une sauvegarde du système (défini PermitRootLogin=yesdans /etc/ssh/sshd_configet redémarrez le serveur).

¹ Vous devriez conserver ce fichier. Vous pouvez y mettre des commentaires sur les lignes commençant par #ou ;. Cela pourrait inclure la rsynccommande réelle , qui peut être copiée plus tard pour que vous n'ayez pas à vous en souvenir à chaque fois.

² Merci à Kris de l'avoir signalé, rsyncne le fait pas automatiquement.

Un script de travail de la communauté des framboises fait par un membre là-bas.

Vous pouvez réutiliser et modifier le code comme bon vous semble. Il est bien documenté et explicite.

#!/bin/bash

# Setting up directories
SUBDIR=raspberrypi_backups
DIR=/hdd/$SUBDIR

echo "Starting RaspberryPI backup process!"

# First check if pv package is installed, if not, install it first
PACKAGESTATUS=`dpkg -s pv | grep Status`;

if [[ $PACKAGESTATUS == S* ]]
   then
      echo "Package 'pv' is installed."
   else
      echo "Package 'pv' is NOT installed."
      echo "Installing package 'pv'. Please wait..."
      apt-get -y install pv
fi

# Check if backup directory exists
if [ ! -d "$DIR" ];
   then
      echo "Backup directory $DIR doesn't exist, creating it now!"
      mkdir $DIR
fi

# Create a filename with datestamp for our current backup (without .img suffix)
OFILE="$DIR/backup_$(date +%Y%m%d_%H%M%S)"

# Create final filename, with suffix
OFILEFINAL=$OFILE.img

# First sync disks
sync; sync

# Shut down some services before starting backup process
echo "Stopping some services before backup."
service apache2 stop
service mysql stop
service cron stop

# Begin the backup process, should take about 1 hour from 8Gb SD card to HDD
echo "Backing up SD card to USB HDD."
echo "This will take some time depending on your SD card size and read performance. Please wait..."
SDSIZE=`blockdev --getsize64 /dev/mmcblk0`;
pv -tpreb /dev/mmcblk0 -s $SDSIZE | dd of=$OFILE bs=1M conv=sync,noerror iflag=fullblock

# Wait for DD to finish and catch result
RESULT=$?

# Start services again that where shutdown before backup process
echo "Start the stopped services again."
service apache2 start
service mysql start
service cron start

# If command has completed successfully, delete previous backups and exit
if [ $RESULT = 0 ];
   then
      echo "Successful backup, previous backup files will be deleted."
      rm -f $DIR/backup_*.tar.gz
      mv $OFILE $OFILEFINAL
      echo "Backup is being tarred. Please wait..."
      tar zcf $OFILEFINAL.tar.gz $OFILEFINAL
      rm -rf $OFILEFINAL
      echo "RaspberryPI backup process completed! FILE: $OFILEFINAL.tar.gz"
      exit 0
# Else remove attempted backup file
   else
      echo "Backup failed! Previous backup files untouched."
      echo "Please check there is sufficient space on the HDD."
      rm -f $OFILE
      echo "RaspberryPI backup process failed!"
      exit 1
fi

Envisagez d'ajouter des commentaires sur le forum d'origine ou de publier votre propre version pour aider à la maturation du contenu. Prenez un peu donner un peu.

* Et merci d'avoir rendu AndersW (script Cliquez pour le GIT)

J'ai adapté @goldilocks answer sur rsync pour la sauvegarde sur le pi. Je sauvegarde sur une ext4partition d'un disque dur monté sur le Pi. Si le disque dur n'est pas monté, rsync serait copié dans le répertoire de montage (jusqu'à ce que la carte SD soit pleine). Si le disque dur n'est pas monté en rwmode, de nombreux messages d'erreur sont générés. Aucune de ces méthodes n’est souhaitable, je vérifie donc que ma partition est montée en rwmode avant de continuer.

NOTE 2015-03-03 J'ai modifié ma réponse pour copier avec précision les liens physiques. L'original a fonctionné, mais a converti de nombreux liens fixes en fichiers. En plus de gaspiller de l'espace, cela compromet de nombreuses utilisations qui supposent que les liens physiques sont en place. (Mon image actuelle contient 869 liens, dont beaucoup dans Raspbian même.)

Mon script pour faire cela suit. (Ma partition est PiDatamontée sur/mnt/PiData

#!/bin/bash
# script to synchronise Pi files to backup
BACKUP_MOUNTED=$(mount | awk '/PiData/ {print $6}' | grep "rw")
if [ $BACKUP_MOUNTED ]; then
    echo $BACKUP_MOUNTED
    echo "Commencing Backup"
    rsync -avH --delete-during --delete-excluded --exclude-from=/usr/bin/rsync-exclude.txt / /mnt/PiData/PiBackup/
else
    echo "Backup drive not available or not writable"
fi

Restaurez (ou mettez à jour un autre Pi) avec les éléments suivants: -

sudo rsync -avH /mnt/PiData/PiBackup/ /

J'ai amélioré le rsync-exclude.txtpour éliminer les fichiers inutiles.

Le premier groupe est constitué des répertoires documentés par @goldilocks https://raspberrypi.stackexchange.com/users/5538/

Le deuxième groupe est constitué des fichiers et des répertoires créés par OS X lorsque j'accède à mon Pi en utilisant AFP (Apple Filing Protocol). (Celles-ci sont normalement invisibles sous OS X, mais pas sous Raspbian. En tout état de cause, il n'est pas nécessaire de faire une sauvegarde.) Même si vous n'utilisez jamais AFP, cela ne fera aucun mal.

Le troisième groupe est constitué des fichiers qui n'ont pas besoin d'être sauvegardés (et certainement pas copiés sur un autre Pi). Exemples fake-hwclock.data, rapports RPi-Monitor. Vous aurez probablement d'autres.

/proc/*
/sys/*
/dev/*
/boot/*
/tmp/*
/run/*
/mnt/*

.Trashes
._.Trashes
.fseventsd
.Spotlight-V100
.DS_Store
.AppleDesktop
.AppleDB
Network Trash Folder
Temporary Items

.bash_history
/etc/fake-hwclock.data
/var/lib/rpimonitor/stat/

J'ai trois PIS qui fonctionnent dans mon réseau local et j'ai besoin de les sauvegarder sur une base régulière avec cron lorsqu'ils sont opérationnels. C'est pourquoi j'ai créé un script capable de créer et de restaurer des sauvegardes dd, tar et rsync. Je préfère utiliser rsync pour mes sauvegardes mais d’autres préfèrent dd ou tar. Il est déjà utilisé par beaucoup de gens. J'espère que c'est utile pour les autres aussi :-) raspibackup - Raspberry crée des sauvegardes de lui-même

Voici notre outil stable à cette fin: https://github.com/aktos-io/aktos-dcs-tools

Cet outil est écrit make sshconnexions, make backup-root, make mount-rootdes endroits éloignés à l' esprit d'abord, puis des sessions locales sont ajoutées. Donc, il prend en charge les sauvegardes locales, les sauvegardes à distance directes, les sauvegardes à distance proxy. Les sauvegardes sont effectuées de manière incrémentielle (seuls les diff sont transférés) et les répertoires de sauvegarde sont autonomes (il suffit de choisir un répertoire / une version à restaurer, tout répertoire ayant une sauvegarde complète). Bien sûr, vous avez des versions (backup.last-0 est la plus récente). Vous pouvez interrompre le processus de sauvegarde à tout moment et continuer plus tard.

Voici les instructions pour votre problème spécifique:

 ssh to-your-raspberry
 cd /mnt/usb0/my-rpi-backups
 git clone https://github.com/ceremcem/aktos-dcs-tools backup-tools
 ln -s backup-tools/Makefile .

 ./backup-tools/configure # you do not need to make any settings for local sessions, just save the default 

 # just for the first time
 make set-local-session  # a flag file is created
 make init               # snapshots directory is created

 # anytime you want to back up
 make backup-root        # backup with rsync

MODIFIER

Une nouvelle cible est maintenant ajoutée: vous pouvez créer une carte SD physique à partir de vos sauvegardes en une seule commande:

make create-disk-from-last-backup

Suivez les instructions, créez votre carte SD, démarrez RaspberryPi avec cette nouvelle carte SD.

Voici une approche complètement différente. Vous pouvez utiliser LVM ( L ogique V olume M pour faire des sauvegardes cohérentes de GESTIONNAIRE). Outre d'autres améliorations telles que l'ajout, l'expansion et la réduction de l'espace de stockage ou la restauration du système d'exploitation à un état antérieur à partir d'un instantané, vous pouvez également effectuer des sauvegardes. Vous ne vous inquiétez pas des fichiers dynamiques modifiés lors de la sauvegarde, de la configuration des systèmes de fichiers en lecture seule, de l’exclusion de répertoires spécifiques ou de quelque chose d’autre. Avec LVM, vous créez simplement un instantané, montez cet instantané et sauvegardez-le avec la méthode que vous préférez. Vous pouvez faire une copie avec cp -a, faire un miroir avec rsync, créer une archive avec tarou créer une image avecdd. En supposant que vous ayez monté un périphérique de sauvegarde, /mnt/usbhd/pi_backup/vous pouvez par exemple:

rpi ~$ sudo lvcreate --snapshot --name rpi_snap --size 1G rpi_vg/root_lv
rpi ~$ sudo mkdir /mnt/snapshot
rpi ~$ sudo mount /dev/mapper/rpi_vg-rpi_snap /mnt/snapshot

# make backups
rpi ~$ sudo cp -a /mnt/snapshot/ /mnt/usbhd/pi_backup/
rpi ~$ sudo rsync -aH --delete /mnt/snapshot/ /mnt/usbhd/pi_backup/
rpi ~$ sudo tar -czf /mnt/usbhd/pi_backup/backup.tar.gz -V "Backup of my Raspberry Pi" -C /mnt/snapshot/ ./
rpi ~$ sudo dd if=/mnt/snapshot/ of=/mnt/usbhd/pi_backup/backup.img bs=4M

rpi ~$ sudo umount /mnt/snapshot/
rpi ~$ sudo lvremove rpi_vg/rpi_snap

Il suffit d’un petit effort pour configurer LVM . Pour ce faire, vous pouvez consulter les sauvegardes et instantanés faciles d’un système en cours d’exécution avec LVM .

J'ai trouvé un outil de sauvegarde permettant de créer des images.

Il a également des utilitaires pour monter et réduire les images.

Cela peut être utile aux autres

La documentation qui l'accompagne est très brève et je note ce qui suit: -

1. Extrayez les utilitaires dans n’importe quel répertoire et rendez les scripts exécutables.
2. Montez une ext4partition formatée sur votre Pi en /mntou /media(tout format autorisant des fichiers volumineux et pris en charge par Pi, par exemple exFAT ou un lecteur réseau peut être utilisé).
3. Pour la première exécution, un nom d’image de sauvegarde vous sera demandé, par exemple: /mnt/Image/BusterBackup.img
4. Une taille de système de fichiers Image ROOT (en Mo) vous sera demandée. Elle peut être 0 pour la plus petite possible ou vide pour une sauvegarde complète.
5. Lors des exécutions suivantes, entrez le chemin de l'image de sauvegarde à mettre à jour de manière incrémentielle.

An example of the commands I used:-
# Mount USB
sudo mount /dev/sda1 /mnt/Image/
# Update backup
sudo image-utils/image-backup /mnt/Image/BusterBackup.img
# Mount backup
sudo image-utils/image-mount /mnt/Image/BusterBackup.img  MountedImages
When done, run:
sudo umount MountedImages; sudo losetup -d /dev/loop0
# Compress backup
sudo sh -c "gzip -9c /mnt/Image/BusterBackup.img  > Images/BusterBackup.img.gz"

J'ai légèrement modifié l'original (pour copier des points de montage), afin de calculer correctement les décalages et les tailles de partition et d'ajouter quelques commentaires.

#!/bin/bash
# Original https://raspberrypi.org/forums/viewtopic.php?p=1528736
# 2019-09-26    Modified to set size of boot sector

trap '{ stty sane; echo ""; errexit "Aborted"; }' SIGINT SIGTERM

ADDBLK=0

# Set BOOT_SIZE_MB to the Desired boot sector size (in MB) - should be multiple of 4MB
BOOT_SIZE_MB=256
BOOTSIZEM=$BOOT_SIZE_MB'M'

BOOTBEG=8192
BOOT_SIZE="$((BOOT_SIZE_MB * 1024 * 1024))"
ROUND_SIZE="$((4 * 1024 * 1024))"
# Ensure root sector starts on an Erase Block Boundary (4MB)
ROOTBEG=$(((BOOT_SIZE + ROUND_SIZE -1) / ROUND_SIZE * ROUND_SIZE / 512 + BOOTBEG))

MNTPATH="/tmp/img-backup-mnt"

ONEMB=$((1024 * 1024))

# create BOOT loop device
mkloop1()
{
  local INFO1=""
  local SIZE1=0
  local START1=0

  sync
  INFO1="$(sfdisk -d "${IMGFILE}")"
  START1=$(grep type=c <<< "${INFO1}" | sed -n 's|^.*start=\s\+\([0-9]\+\).*$|\1|p')
  SIZE1=$(grep type=c <<< "${INFO1}" | sed -n 's|^.*size=\s\+\([0-9]\+\).*$|\1|p')
  LOOP1="$(losetup -f --show -o $((${START1} * 512)) --sizelimit $((${SIZE1} * 512)) "${IMGFILE}")"
  if [ $? -ne 0 ]; then
    errexit "Unable to create BOOT loop device"
  fi
}

rmloop1()
{
  if [ "${LOOP1}" != "" ]; then
    sync
    losetup -d "${LOOP1}"
    LOOP1=""
 fi
}

# create ROOT loop device
mkloop2()
{
  local INFO2=""
  local SIZE2=0
  local START2=0

  sync
  INFO2="$(sfdisk -d "${IMGFILE}")"
  START2=$(grep type=83 <<< "${INFO2}" | sed -n 's|^.*start=\s\+\([0-9]\+\).*$|\1|p')
  SIZE2=$(grep type=83 <<< "${INFO2}" | sed -n 's|^.*size=\s\+\([0-9]\+\).*$|\1|p')
  LOOP2="$(losetup -f --show -o $((${START2} * 512)) --sizelimit $((${SIZE2} * 512)) "${IMGFILE}")"
  if [ $? -ne 0 ]; then
    errexit "Unable to create ROOT loop device"
  fi
}

rmloop2()
{
  if [ "${LOOP2}" != "" ]; then
    sync
    losetup -d "${LOOP2}"
    LOOP2=""
  fi
}

# Mount Image partitions
mntimg()
{
  MNTED=TRUE
  if [ ! -d "${MNTPATH}/" ]; then
    mkdir "${MNTPATH}/"
    if [ $? -ne 0 ]; then
      errexit "Unable to make ROOT partition mount point"
    fi
  fi
  mkloop2
  mount "${LOOP2}" "${MNTPATH}/"
  if [ $? -ne 0 ]; then
    errexit "Unable to mount image ROOT partition"
  fi
  if [ ! -d "${MNTPATH}/boot/" ]; then
    mkdir -p "${MNTPATH}/boot/"
    if [ $? -ne 0 ]; then
      errexit "Unable to make BOOT partition mount point"
    fi
  fi
  mkloop1
  mount "${LOOP1}" "${MNTPATH}/boot/"
  if [ $? -ne 0 ]; then
    errexit "Unable to mount image BOOT partition"
  fi
}

umntimg()
{
  umount "${MNTPATH}/boot/"
  if [ $? -ne 0 ]; then
    errexit "Unable to unmount image BOOT partition"
  fi
  rmloop1
  umount "${MNTPATH}/"
  if [ $? -ne 0 ]; then
    errexit "Unable to unmount image ROOT partition"
  fi
  rmloop2
  rm -r "${MNTPATH}/"
  MNTED=FALSE
}

errexit()
{
  echo ""
  echo "$1"
  echo ""
  if [ "${MNTED}" = "TRUE" ]; then
    umount "${MNTPATH}/boot/" &> /dev/null
    umount "${MNTPATH}/" &> /dev/null
    rm -rf "${MNTPATH}/" &> /dev/null
  fi
  rmloop1
  rmloop2
  exit 1
}

LOOP1=""
LOOP2=""
MNTED=FALSE

PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin

if [ $(id -u) -ne 0 ]; then
  errexit "$0 must be run as root user"
fi

PGMNAME="$(basename $0)"
for PID in $(pidof -x -o %PPID "${PGMNAME}"); do
  if [ ${PID} -ne $$ ]; then
    errexit "${PGMNAME} is already running"
  fi
done

rsync --version &> /dev/null
if [ $? -ne 0 ]; then
  errexit "rsync not installed (run: apt-get install rsync)"
fi

if command -v systemctl > /dev/null && systemctl | grep -q '\-\.mount'; then
  SYSTEMD=1
elif [ -f /etc/init.d/cron ] && [ ! -h /etc/init.d/cron ]; then
  SYSTEMD=0
else
  errexit "Unrecognized init system"
fi

if [ ${SYSTEMD} -eq 1 ]; then
  ROOT_PART="$(mount | sed -n 's|^/dev/\(.*\) on / .*|\1|p')"
else
  if [ ! -h /dev/root ]; then
    errexit "/dev/root does not exist or is not a symlink"
  fi
  ROOT_PART="$(readlink /dev/root)"
fi

ROOT_TYPE=$(blkid "/dev/${ROOT_PART}" | sed -n 's|^.*TYPE="\(\S\+\)".*|\1|p')

ROOT_DEV="${ROOT_PART:0:(${#ROOT_PART} - 1)}"
if [ "${ROOT_DEV}" = "mmcblk0p" ]; then
  ROOT_DEV="${ROOT_DEV:0:(${#ROOT_DEV} - 1)}"
fi

PTUUID="$(blkid "/dev/${ROOT_DEV}" | sed -n 's|^.*PTUUID="\(\S\+\)".*|\1|p')"

DEVSIZE=$(blockdev --getsize64 "/dev/${ROOT_PART}")
BLKSIZE=$(blockdev --getbsz "/dev/${ROOT_PART}")
BLKCNT=$((${DEVSIZE} / ${BLKSIZE}))
INFO="$(df | grep /dev/root)"
DFKSIZE=$(awk '{print $2}' <<< "${INFO}")
DFKFREE=$(awk '{print $4}' <<< "${INFO}")
ROOTSIZE=$((${BLKCNT} * ${BLKSIZE}))
ROOTUSED=$(((${DFKSIZE} - ${DFKFREE}) * 1024))
IRFSMIN=$(((${ROOTUSED} + (${ADDBLK} * ${BLKSIZE}) + (${ONEMB} - 1)) / ${ONEMB}))
IRFSMAX=$(((${ROOTSIZE} + (${ONEMB} - 1)) / ${ONEMB}))

IMGFILE="$1"
if [ "${IMGFILE}" = "" ]; then
# Create Image file
  while :
  do
    echo ""
    read -r -e -i "${IMGFILE}" -p "Image file to create? " IMGFILE
    if [ "${IMGFILE}" = "" ]; then
      continue
    elif [[ ! "${IMGFILE}" =~ ^/mnt/.*$ && ! "${IMGFILE}" =~ ^/media/.*$ ]]; then
      echo ""
      echo "${IMGFILE} does not begin with /mnt/ or /media/"
      continue
    fi
    if [ -d "${IMGFILE}" ]; then
      echo ""
      echo "${IMGFILE} is a directory"
    elif [ -f "${IMGFILE}" ]; then
      echo ""
      echo -n "${IMGFILE} already exists, Ok to delete (y/n)? "
      while read -r -n 1 -s answer; do
        if [[ "${answer}" = [yYnN] ]]; then
          echo "${answer}"
          if [[ "${answer}" = [yY] ]]; then
            break 2
          else
            break 1
          fi
        fi
      done
    else
      break
    fi
  done
  IRFSSIZE=""
  while :
  do
    echo ""
    read -r -e -i "${IRFSSIZE}" -p "Image ROOT filesystem size (MB) [${IRFSMAX}]? " IRFSSIZE
    if [ "${IRFSSIZE}" = "" ]; then
      IRFSSIZE=${IRFSMAX}
      break
    elif [ ${IRFSSIZE} -ge ${IRFSMIN} ]; then
      break
    else
      echo ""
      echo "Requested image ROOT filesystem size (${IRFSSIZE}) is too small (Minimum = ${IRFSMIN})"
      IRFSSIZE=${IRFSMIN}
    fi
  done
  echo ""
  echo -n "Create ${IMGFILE} [${IRFSSIZE} MB] (y/n)? "
  while read -r -n 1 -s answer; do
    if [[ "${answer}" = [yYnN] ]]; then
      echo "${answer}"
      if [[ "${answer}" = [yY] ]]; then
        break
      else
        errexit "Aborted"
      fi
    fi
  done
  if [ -f "${IMGFILE}" ]; then
    rm "${IMGFILE}"
    if [ $? -ne 0 ]; then
      errexit "Unable to delete existing image file"
    fi
  fi
  ROOTEND=$((${ROOTBEG} + ((${IRFSSIZE} * ${ONEMB}) / 512) - 1))
  truncate -s $(((${ROOTEND} + 1) * 512)) "${IMGFILE}"
  if [ $? -ne 0 ]; then
    errexit "Unable to create image file"
  fi
# create image/partitions
  sync
  fdisk "${IMGFILE}" <<EOF > /dev/null
p
n
p
1
${BOOTBEG}
+${BOOTSIZEM}
t
c
p
n
p
2
${ROOTBEG}
${ROOTEND}
p
w
EOF

  mkloop1
  mkloop2
  mkfs.vfat "${LOOP1}" > /dev/null
  if [ $? -ne 0 ]; then
    errexit "Unable to create image BOOT filesystem"
  fi
  dosfsck "${LOOP1}" > /dev/null
  if [ $? -ne 0 ]; then
    errexit "Image BOOT filesystem appears corrupted"
  fi
  if [ "${ROOT_TYPE}" = "f2fs" ]; then
    mkfs.f2fs "${LOOP2}" > /dev/null
  else
    mkfs.ext4 -q -b ${BLKSIZE} "${LOOP2}" > /dev/null
  fi
  if [ $? -ne 0 ]; then
    errexit "Unable to create image ROOT filesystem"
  fi
  rmloop2
  rmloop1
# Initialise image PARTUUID
  fdisk "${IMGFILE}" <<EOF > /dev/null
p
x
i
0x${PTUUID}
r
p
w
EOF
# Create empty directories in image root partition
  mntimg
  mkdir "${MNTPATH}/dev/" "${MNTPATH}/media/" "${MNTPATH}/mnt/" "${MNTPATH}/proc/" "${MNTPATH}/run/" "${MNTPATH}/sys/" "${MNTPATH}/tmp/"
  if [ $? -ne 0 ]; then
    errexit "Unable to create image directories"
  fi
  chmod a+rwxt "${MNTPATH}/tmp/"
  umntimg
  echo ""
  echo "Starting full backup (for incremental backups, run: $0 ${IMGFILE})"
# END of create image/partitions
else

# Check existing Image
  if [[ ! "${IMGFILE}" =~ ^/mnt/.*$ && ! "${IMGFILE}" =~ ^/media/.*$ ]]; then
    errexit "${IMGFILE} does not begin with /mnt/ or /media/"
  fi
  if [ -d "${IMGFILE}" ]; then
    errexit "${IMGFILE} is a directory"
  elif [ ! -f "${IMGFILE}" ]; then
    errexit "${IMGFILE} not found"
  fi
  echo "Starting incremental backup to ${IMGFILE}"
fi

# rsync root partition
mntimg
sync
rsync -aDH --partial --numeric-ids --delete --force --exclude "${MNTPATH}" --exclude '/dev' --exclude '/media' --exclude '/mnt/*/*' --exclude '/proc' --exclude '/run' --exclude '/sys' \
--exclude '/tmp' --exclude 'lost\+found' --exclude '/etc/udev/rules.d/70-persistent-net.rules' --exclude '/var/lib/asterisk/astdb.sqlite3-journal' / "${MNTPATH}/"
if [[ $? -ne 0 && $? -ne 24 ]]; then
  errexit "Unable to create backup"
fi
sync
umntimg

Ouvrez le terminal et tapez 'lsblk -f'.
Cela devrait montrer tous les périphériques de stockage connectés.
Puis tapez 'dd if = / dev / [le NOM de votre carte SD] bs = 1M'.
Cela prendra un certain temps, vous voudrez peut-être l'exécuter en arrière-plan.
C’est la même chose que vous sauvegardez votre carte SD sous Linux.