Pertanyaan ini menjawab pertanyaan tentang bagaimana saya menggunakan komputer eksternal untuk membuat cadangan RPi saya.

Saya bertanya-tanya apakah saya dapat membuat gambar cadangan kartu SD yang sedang digunakan, dan menyalinnya ke file di perangkat penyimpanan USB. Apakah ini mungkin? Jika tidak, apakah ada cara untuk membuat cadangan RPi tanpa melibatkan komputer lain?

Inilah pengantar untuk digunakan rsyncuntuk membuat cadangan pada Pi. Setelah pencadangan awal dibuat, tetap perbarui dengan cara ini jauh lebih cepat daripada terus-menerus merobek seluruh gambar. Anda dapat melakukan ini pada hard drive lokal atau melalui jaringan.

Anda sebenarnya tidak ingin salinan lengkap dari sistem yang berjalan sebagai cadangan, karena beberapa hal yang tampaknya ada di sistem file hanya ada saat runtime. Menyertakannya dalam cadangan dan kemudian menggunakannya untuk membuat ulang gambar nanti dapat membuat masalah bagi Anda.

Ada beberapa pengecualian lain juga. rsyncdapat menerima daftar pola ( gumpalan ) untuk dikecualikan, dan itu dapat dibaca dari file, jadi mari kita pergi melalui apa yang seharusnya ada di file seperti itu. Perhatikan bahwa entri berbentuk /directory/*dan bukan /directory. Ini karena kami ingin mereka ada, tetapi kami tidak ingin menyalin apa pun di dalamnya.

/proc/*
/sys/*

Ini tidak benar-benar ada pada disk. Mereka adalah antarmuka ke kernel, yang membuat dan memelihara mereka dalam memori . Jika Anda menyalin ini dan kemudian menyalinnya kembali ke sistem dan mem-bootnya, itu akan (paling tidak) tidak berarti, karena kernel menggunakan itu sebagai titik mount untuk antarmuka [Jika Anda ingin melihat apa yang terjadi ketika Anda memasang partisi sistem file pada direktori dengan data di dalamnya, coba. Ini berfungsi dan tidak akan membahayakan, tetapi barang-barang yang ada di direktori sekarang tidak dapat diakses.]

Perhatikan bahwa sangat penting bahwa /sysdan /proctitik mount ada. Tapi mereka seharusnya tidak mengandung apa pun. Lanjut:

/dev/*

The devdirektori tidak cukup hal yang sama seperti procdan systetapi untuk tujuan kita itu. Jika Anda yakin bahwa Anda harus menyimpan ini sehingga Anda dapat memiliki node perangkat yang sama di cadangan Anda atau sesuatu, Anda salah . Jangan repot-repot. Jangan menyalin dev. Dahulu kala Linux memang bekerja seperti itu, tetapi tidak lagi.

/boot/*

Ini adalah semacam kasus khusus dengan sebagian besar (mungkin semua) distro khusus Pi seperti Raspbian. Ini sebenarnya adalah titik mount untuk partisi pertama, vfat. Kami akan menghadapinya secara terpisah. Apa pun yang Anda lakukan, jangan repot-repot memasukkannya ke sini, karena sekali lagi, ini adalah titik puncak.

/tmp/*
/run/*

/runumumnya tidak pada disk juga, itu di memori. Mungkin /tmpbisa terlalu (ini akan menghemat sedikit aksi kartu SD), tetapi bagaimanapun, seperti namanya, ini bukan tempat untuk menyimpan data yang persisten. Aplikasi yang menggunakannya berharap dapat dihapus pada setiap boot.

/mnt/*
/media/*

Ini penting terutama jika Anda berencana untuk mencadangkan ke hard drive atau stik USB dan perangkat sedang /mntatau /media(otomatis cenderung menggunakan yang terakhir), karena jika Anda tidak mengecualikan lokasi perangkat tersebut di sistem file Anda akan buat loop yang mencadangkan konten drive ke dirinya sendiri, sampai kehabisan ruang. Saya pikir rsync mungkin cukup pintar untuk menemukan sesuatu yang bodoh, tetapi cobalah untuk menghindari pengujian premis.

Aktif ke pencadangan aktual: Buat direktori untuk mencadangkan pada harddrive yang terpasang secara lokal, USB, dll. - mis. "Pi_backup". Anda dapat mem-backup secara bergantian ke lokasi yang jauh melalui ssh(lihat di bawah) atau menggunakan sistem file yang terpasang di jaringan, tetapi ini mungkin akan memakan waktu agak lama untuk pertama kalinya.

Jika file yang berisi daftar untuk dikecualikan adalah /rsync-exclude.txt¹ dan drive Anda adalah /mnt/usbhd, untuk melakukan pencadangan yang sebenarnya:

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

Perhatikan bahwa ada garis miring padapi_backup/ .

Ini akan memakan waktu cukup lama dan menghasilkan banyak output (jika Anda ingin memeriksanya dalam log, tambahkan > rsync.log). --deletetidak ada artinya pertama kali, tetapi untuk menjaga cadangan diperbarui menggunakannya. Ini memastikan bahwa hal-hal yang Anda kemudian hapus pada Pi juga akan dihapus dari cadangan Anda. The aset rekursi ke direktori dan memastikan semua atribut berkas pertandingan. -Hadalah untuk melestarikan hard link ² , vadalah untuk verbose itulah sebabnya Anda mendapatkan beberapa output (jika rsynctidak diam). Lihat man rsynclebih lanjut.

Ada jalan pintas di mana Anda dapat melewati --exclude-fromfile. Jika Anda yakin bahwa semua hal yang tidak ingin Anda salin ( /tmpdll.) Ada di sistem file yang terpisah, Anda bisa menggunakan:

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

-xtelah dimasukkan. Ini adalah bentuk singkat dari --one-file-system, yang memberitahu rsyncuntuk tidak melewati batas filesystem. Secara pribadi saya lebih suka --exclude-from, tetapi pada misalnya, Raspbian default, --one-file-systemakan berfungsi dengan baik. Anda dapat menggunakan keduanya jika ingin -xberhati-hati: D

Itu bukan cadangan yang lengkap. Sudah cukup jika Anda belum memasukkan apa pun bootdan Anda baik-baik saja dengan menggunakan cadangan untuk hanya mengembalikan sistem dengan menempelkan kartu di komputer dan menjalankan:

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

Anda juga dapat melakukan ini dengan kartu dengan gambar baru di atasnya (anggap itu sama dengan gambar dasar Anda) walaupun itu sedikit tidak efisien jika Anda harus membuat gambar (karena Anda kemudian akan menimpa sebagian besar dari itu). Anda juga dapat menghubungkan kartu SD lain melalui adaptor USB dengan gambar seperti itu, dan menggunakan metode di atas untuk mempertahankan kartu duplikat.

Jika Anda memasukkan barang-barang /boot(misalnya, kernel khusus), termasuk /boot/config.txt, Anda juga ingin mencadangkannya (cukup sederhana - tidak banyak). Lakukan saja secara terpisah, dan ketika Anda memulihkan, hal itu masuk di partisi pertama.

Lihat di sini jika Anda ingin membuat gambar gaya Raspbian kosong yang dapat Anda backup. Anda dapat menggunakan metodologi serupa untuk membuat kartu gaya Raspbian kosong - hanya daripada berurusan dengan .imgfile, Anda akan berurusan dengan perangkat nyata (misalnya /dev/sdb), artinya yang harus Anda lakukan adalah membuat tabel partisi dengan fdiskdan kemudian format /dev/sdb1dan sdb2(atau apa pun) dengan mkfs.

Tetapi menyalin seluruh gambar lebih mudah! Kenapa repot-repot dengan ini?

Tidak sesulit itu; Saya mengembalikan ke kartu kosong (diformat sesuai tautan terakhir) dalam 10 menit. Ya, hanya menggunakan ddsemuanya lebih sederhana (jika Anda menemukan hal-hal seperti kata-kata membingungkan ...), TETAPI itu butuh waktu cukup lama setiap kali Anda ingin memperbarui cadangan Anda karena Anda harus melakukan 100% setiap kali. Dengan menggunakan rsync, begitu ada cadangan, memperbarui itu jauh lebih cepat, sehingga Anda dapat mengaturnya agar terjadi tanpa rasa sakit setiap hari melalui cron. Bahkan melalui jaringan. Setiap enam jam. Semakin sering Anda melakukannya, semakin sedikit waktu yang dibutuhkan.

rsync melalui ssh

Ini sebuah contoh:

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

"Opsi" akan menjadi, misalnya, -av --delete --exclude-from=/rsync-exclude.txtdan "opsi ssh" adalah apa pun yang biasanya Anda gunakan (jika ada). Anda harus memiliki akses root melalui sshuntuk melakukan hal ini untuk keperluan backup sistem (set PermitRootLogin=yesdi /etc/ssh/sshd_configdan restart server).

¹ Anda harus menyimpan file ini. Anda dapat memberikan komentar di dalamnya pada baris yang dimulai dengan #atau ;. Ini bisa termasuk rsyncperintah aktual , yang dapat disalin kemudian disalin sehingga Anda tidak harus mengingatnya setiap kali.

² Terima kasih kepada Kris karena menunjukkan rsynctidak melakukan ini secara otomatis.

Sebuah skrip yang berfungsi dari Komunitas Raspberry dibuat oleh anggota di sana.

Anda dapat menggunakan kembali dan mengubah kode sesuka Anda. Ini didokumentasikan dengan baik dan cukup jelas.

#!/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

Pertimbangkan untuk menambahkan komentar ke forum asli atau memposting versi Anda sendiri untuk membantu mematangkan konten. Ambil sedikit, beri sedikit.

* Dan terima kasih telah memberikan kembali AndersW (Klik untuk skrip GIT)

Saya telah mengadaptasi jawaban @goldilocks pada rsync untuk cadangan pada pi. Saya mencadangkan ke ext4partisi pada HDD yang dipasang pada Pi. Jika HDD tidak dipasang, rsync akan menyalin ke direktori pemasangan (hingga SD Card penuh). Jika HDD tidak dipasang dalam rwmode pesan kesalahan berlebihan diproduksi. Tidak satu pun dari ini diinginkan, jadi saya memeriksa apakah partisi saya sudah terpasang dalam rwmode sebelum melanjutkan.

CATATAN 2015-03-03 Saya mengubah jawaban saya untuk menyalin hardlink secara akurat. Dokumen asli berfungsi, tetapi mengubah banyak hardlink menjadi file. Selain membuang-buang ruang, kompromi ini banyak menggunakan yang menganggap hardlink ada di tempat. (Gambar saya saat ini memiliki 869 tautan, banyak di Raspbian itu sendiri.)

Script saya untuk melakukan ini adalah sebagai berikut. (Partisi saya sudah PiDataterpasang/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

Pulihkan (atau perbarui Pi lain) dengan yang berikut: -

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

Saya telah meningkatkan rsync-exclude.txtuntuk menghilangkan file yang tidak perlu.

Grup pertama adalah direktori yang didokumentasikan oleh @goldilocks https://raspberrypi.stackexchange.com/users/5538/

Grup kedua adalah file dan direktori yang dibuat oleh OS X ketika saya mengakses Pi saya menggunakan AFP (Apple Filing Protocol). (Ini biasanya tidak terlihat pada OS X, tetapi tidak pada Raspbian. Dalam hal apapun, tidak perlu cadangan.) Bahkan jika Anda tidak pernah menggunakan AFP, ini tidak akan membahayakan.

Grup ketiga adalah file yang tidak perlu dicadangkan (dan tentu saja tidak disalin ke Pi lain). Contohnya palsu-hwclock.data, laporan RPi-Monitor. Anda mungkin akan memiliki orang lain.

/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/

Saya memiliki tiga PIS yang berjalan di jaringan lokal saya dan perlu membackupnya secara reguler dengan cron ketika sedang aktif. Itu sebabnya saya membuat skrip yang dapat membuat cadangan dd, tar dan rsync dan untuk mengembalikannya. Saya lebih suka menggunakan rsync untuk cadangan saya tetapi orang lain lebih suka dd atau tar. Ini sudah digunakan oleh banyak orang. Semoga bermanfaat bagi orang lain juga :-) raspibackup - Raspberry membuat cadangan sendiri

Berikut ini adalah alat stabil kami untuk tujuan tersebut: https://github.com/aktos-io/aktos-dcs-tools

Alat ini ditulis untuk make sshkoneksi, make backup-root, make mount-rootdari tempat-tempat terpencil di pikiran pada awalnya, dan kemudian sesi lokal ditambahkan. Jadi mendukung backup lokal, backup jarak jauh langsung, backup jarak jauh proxy. Cadangan diambil secara bertahap (hanya perbedaan yang ditransfer) dan direktori pencadangan berdiri sendiri (cukup pilih direktori / versi untuk dipulihkan, direktori mana pun memiliki cadangan lengkap). Tentu saja, Anda memiliki versi (backup.last-0 adalah yang terbaru). Anda dapat menghentikan proses pencadangan kapan saja dan melanjutkan nanti.

Berikut adalah instruksi untuk masalah spesifik Anda:

 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

SUNTING

Sekarang ada target baru yang ditambahkan: Anda dapat membuat Kartu SD fisik dari cadangan Anda dengan satu perintah:

make create-disk-from-last-backup

Ikuti instruksi, buat SD Card Anda, boot RaspberryPi dengan SD Card yang baru dibuat ini.

Berikut ini adalah pendekatan berbeda yang lengkap. Anda dapat menggunakan LVM ( L ogical V olume M anager ) untuk membuat cadangan yang konsisten. Selain peningkatan lainnya seperti penambahan, perluasan, dan penyimpanan yang mudah atau mengembalikan sistem operasi ke status sebelumnya dari snapshot, Anda juga dapat membuat cadangan. Anda tidak perlu khawatir tentang file berubah dinamis selama cadangan, pengaturan sistem file hanya baca, mengecualikan direktori tertentu atau sesuatu yang lain. Dengan LVM Anda cukup membuat snapshot, pasang snapshot ini dan cadangkan dengan metode yang Anda inginkan. Anda dapat membuat salinan dengan cp -a, membuat cermin dengan rsync, membuat arsip dengan, taratau membuat gambar dengandd. Dengan asumsi Anda telah memasang perangkat cadangan yang /mnt/usbhd/pi_backup/dapat Anda lakukan misalnya:

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

Hanya perlu sedikit usaha untuk mengatur LVM . Cara melakukannya, Anda dapat melihat Easy backups dan snapshots dari sistem yang sedang berjalan dengan LVM .

Saya telah menemukan alat cadangan yang membuat gambar dapat diinstal.

Ini juga memiliki utilitas untuk memasang dan mengecilkan gambar.

Ini mungkin bermanfaat bagi orang lain

Dokumentasi yang menyertainya sangat singkat sehingga saya perhatikan hal berikut: -

1. Ekstrak utilitas ke direktori mana pun dan buat skrip dapat dieksekusi.
2. Pasang ext4partisi yang diformat pada Pi Anda di /mntatau /media(format apa pun yang memungkinkan file besar dan didukung oleh Pi misalnya exFAT atau drive jaringan dapat digunakan).
3. Untuk proses awal Anda akan diminta untuk nama Gambar Cadangan misalnya /mnt/Image/BusterBackup.img
4. Anda akan diminta untuk ukuran sistem file ROOT Gambar (dalam MB), ini bisa 0 untuk kemungkinan terkecil atau kosong untuk cadangan penuh.
5. Saat berjalan berikutnya masukkan jalur Gambar Cadangan untuk memperbarui secara bertahap.

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"

Saya telah sedikit memodifikasi dokumen asli (untuk menyalin mountpoints), untuk menghitung dengan benar ukuran dan ukuran partisi dan menambahkan beberapa komentar.

#!/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

Buka terminal dan ketik 'lsblk -f'.
Ini harus menunjukkan semua perangkat penyimpanan yang terhubung.
Kemudian ketik 'dd if = / dev / [NAMA kartu sd Anda] bs = 1M'.
Ini akan memakan waktu cukup lama sehingga Anda mungkin ingin menjalankannya di latar belakang.
Ini adalah cara persis yang sama Anda membuat cadangan kartu sd Anda di Linux.