Bu soru , RPI'mın bir yedeğini oluşturmak için harici bir bilgisayarı nasıl kullandığım sorusunu yanıtlıyor.

Şu anda kullanımda olan SD kartın yedek bir görüntüsünü oluşturabilir miyim ve USB depolama aygıtındaki bir dosyaya kopyalayıp kopyalayamayacağımı merak ediyorum. Mümkün mü? Değilse, başka bir bilgisayarı dahil etmeden bir RPI yedeği oluşturmanın bir yolu var mı?

İşte Pi'ye rsyncyedekleme yapmak için bir giriş . İlk yedek oluşturulduktan sonra, bu şekilde güncel tutmak tüm görüntüyü sürekli kopyalamaktan çok daha hızlıdır. Bunu yerel bir sabit sürücüye veya bir ağ üzerinden yapabilirsiniz.

Aslında çalışan bir sistemin tam bir kopyasını yedek olarak istemiyorsunuz, çünkü dosya sistemindeki görünüşte bazı şeyler yalnızca çalışma zamanında var. Bir yedekleme o dahil ve daha sonra bir görüntü yaratmak için kullanmaya olabilir sizin için sorun yaratabilir.

Başka istisnalar da var. Hariç tutulacak rsync( glob ) desenlerin bir listesini kabul edebilir ve bunlar bir dosyadan okunabilir, bu yüzden ilk önce böyle bir dosyada ne olması gerektiğini gözden geçirelim. Girişlerin formda /directory/*olup olmadığını unutmayın /directory. Bunun nedeni bizlerin var olmasını istiyoruz, fakat onlarda hiçbir şey kopyalamak istemiyoruz.

/proc/*
/sys/*

Bunlar gerçekten diskte yok. Onlar çekirdeğe bir arayüzdür, bu onları yaratır ve bellekte tutar . Bunları kopyalarsanız ve tekrar sisteme kopyalarsanız ve başlatırsanız, en iyisi anlamsız olacaktır, çünkü çekirdek bunları arayüzler için bağlama noktaları olarak kullanır. veri içeren bir dizinde deneyin. Çalışır ve herhangi bir zarar vermez, ancak dizinde bulunan şeylere erişilemez.]

/sysVe /procbağlama noktalarının var olmasının kritik olduğunu unutmayın . Ancak hiçbir şey içermemelidir. Sonraki:

/dev/*

devDizin ile aynı şey değildir procve sysancak o bizim için. Bunu kaydetmeniz gerektiğine inanıyorsanız, aynı cihaz düğümlerini yedeklemenizde veya başka bir şeyde kullanabilmeniz için yanılıyorsunuz . Rahatsız etme. Kopyalamayın dev. Bir zamanlar bir zamanlar önce Linux bu şekilde çalışıyordu, ama artık çalışmıyor.

/boot/*

Bu, Raspbian gibi Pi'ye özgü dağıtımların çoğu (belki de tamamı) olan özel bir durumdur. Aslında ilk bölüm, bölüm, bölüm için bir bağlantı noktası. Bununla ayrı ayrı ilgileneceğiz. Ne yaparsan yap, buraya dahil etme zahmet etmeyin, çünkü yine de bir bağlantı noktası.

/tmp/*
/run/*

/rungenellikle diskte de değildir, bellektedir. Belki de /tmpolabilir (bu, bir miktar SD kart işleminden tasarruf sağlar), ancak her durumda, adından da anlaşılacağı gibi, bunlar kalıcı veri depolamak için yer değildir. Onları kullanan uygulamalar, her önyüklemede silinmelerini bekler.

/mnt/*
/media/*

Bunlar, özellikle bir sabit diske veya USB belleğe yedekleme yapmayı planlıyorsanız ve cihaz içerideyse /mntveya /media(otomatik olarak sonuncuyu kullanma eğilimi varsa), çünkü bu cihazların dosya sistemindeki yerini dışlamazsanız, alanın tükenene kadar sürücünün içeriğini kendisine yedekleyen bir döngü oluşturun. Bence aptalca bir şeyi fark edecek kadar akıllı rsync olabilir , ama öncül test etmekten kaçınmaya çalış.

Gerçek yedeklemede: Yerel olarak monte edilmiş sabit sürücüde, USB şeyinde, vb. Yedeklemek için bir dizin oluşturun - örneğin "pi_backup". Alternatif olarak uzak bir konuma ssh(aşağıya bakınız) veya ağa bağlı bir dosya sistemi kullanarak yedekleme yapabilirsiniz , ancak bu muhtemelen ilk kez bir süre alacaktır.

Hariç tutulacak listeyi içeren dosya /rsync-exclude.txt^{1 ise} ve sürücünüz ise /mnt/usbhd, asıl yedeklemeyi yapmak için:

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

Üzerine bir eğik çizgi olduğuna dikkat edinpi_backup/ .

Bu biraz zaman alacaktır ve çok fazla çıktı üretecektir (bunu bir günlükte incelemek istiyorsanız, ekleyin > rsync.log). --deleteilk kez anlamsızdır, ancak yedeği güncel tutmak için onu kullanın. Bu, daha sonra Pi'de sildiğiniz şeylerin de yedeklemenizden kaldırılmasını sağlar. aVe dizinlere setleri tekrarlama tüm dosya maç niteliklerini emin olur. sabit bağlantıları-H korumaktır ( ²⁾ , bu nedenle bazı çıktılar alırsınız (aksi halde sessiz). Daha fazlasını gör .vrsyncman rsync

--exclude-fromDosyayı atlayabileceğiniz bir kısayol var . Kopyalamak istemediğiniz her şeyin ( /tmpvb.) Ayrı dosya sistemlerinde olduğundan eminseniz, yalnızca şunları kullanabilirsiniz:

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

-xyerleştirildi. Bu, dosya sistemi sınırlarını geçmemeyi --one-file-systemsöyleyen kısa şeklidir rsync. Şahsen ben tercih ediyorum --exclude-from, ama örneğin, varsayılan Raspbian, --one-file-systemiyi çalışacak. -xDikkatli olmak istiyorsanız her ikisini de kullanabilirsiniz : D

Bu tam bir yedekleme değil. Herhangi bir şey yerleştirmediyseniz bootve kartı bir bilgisayara takarak ve çalıştırarak sistemi geri yüklemek için yedeklemeyi kullanmanız yeterlidir :

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

Bunu, üzerinde yeni bir görüntü olan bir kartla da yapabilirsiniz (bunun temel görüntünüzle aynı olduğunu varsayarak), ancak görüntüyü oluşturmak zorunda kalırsanız bu biraz verimsizdir (çünkü daha sonra üzerine yazacaksınız). Ayrıca üzerinde bir görüntü bulunan bir USB adaptörüyle başka bir SD kartı da bağlayabilir ve bir kopya kartı korumak için yukarıdaki yöntemi kullanabilirsiniz.

İçerdiği şeyleri /boot(örneğin, özel bir çekirdeği) koyduysanız /boot/config.txt, bunu da yedeklemek istersiniz (oldukça basit - fazla bir şey yoktur). Sadece ayrı ayrı yapın ve geri yüklediğinizde, bu şeyler ilk bölüme gider.

Daha sonra yedekleyebileceğiniz boş bir Raspbian tarzı resim oluşturmak istiyorsanız, buraya bakın . Boş bir Raspbian tarzı kart oluşturmak için benzer bir metodoloji kullanabilirsiniz - bir .imgdosyayla uğraşmak yerine, gerçek bir cihazla (örneğin /dev/sdb) uğraşırsınız , yani tek yapmanız gereken bölüm tablosunu oluşturmak fdiskve sonra kullanmaktır. biçimlendirin /dev/sdb1ve sdb2(veya herhangi bir şekilde) mkfs.

Ancak tüm görüntünün kopyalanması daha kolaydır! Neden bununla uğraşmıyorsun?

O kadar zor değil; 10 dakika içinde boş bir karta (son bağlantıya göre biçimlendirilmiş) geri yükledim. Evet, sadece ddher şeyi kullanmak daha basittir (kelimelerin kafa karıştırıcı gibi şeyler bulursanız…), ANCAK, yedeklemenizi güncellemek istediğinizde her zaman biraz zaman alır, çünkü her seferinde% 100'ünü yapmanız gerekir. Kullanılması rsyncbir yedek var olduğunda cron üzerinden acısız günlük bir yapılacak şekilde ayarlayabilirsiniz, böylece, bu güncelleme, çok daha hızlıdır. Hatta bir ağ üzerinden. Her altı saatte bir. Ne kadar sıklıkla yaparsanız, o kadar az zaman alır.

rsync üzerinden ssh

İşte bir örnek:

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

"Seçenekler", mesela, -av --delete --exclude-from=/rsync-exclude.txtve "ssh seçenekleri" normalde ne kullanıyorsanız (bir şey varsa) olacaktır. Aracılığıyla Kök erişimi olmalıdır sshsistem yedekleme amaçları (set için bunu PermitRootLogin=yesiçinde /etc/ssh/sshd_configve sunucuyu yeniden başlatın).

¹ Bu dosyayı saklamanız gerekir. İçinde #veya ile başlayan satırlara yorum yazabilirsiniz ;. Bu rsync, daha sonra yapıştırılan gerçek komutu içerebilir, böylece her seferinde hatırlamanıza gerek kalmaz.

² Kris için teşekkür ederim, rsyncotomatik olarak bunu yapmaz.

Burada bir üye tarafından yapılan Ahududu Topluluğu'ndan çalışan bir senaryo.

İstediğiniz zaman kodu yeniden kullanabilir ve değiştirebilirsiniz. İyi belgelenmiştir ve açıklayıcıdır.

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

Orijinal foruma yorum eklemeyi düşünün veya içeriği geliştirmek için kendi sürümünüzü yayınlayın. Biraz al biraz ver.

* Ve AndersW'i geri verdiğiniz için teşekkür ederiz (GIT betiği için tıklayın)

Ben goldilocks Pi Pi yedek rsync üzerinde cevap cevap adapte var. ext4Pi'ye monte edilmiş bir HDD'deki bölüme yedekleme yapıyorum . HDD takılı değilse, rsync takma dizinine kopyalar (SD Kart dolana kadar). HDD rwmoda monte edilmezse, çok fazla hata mesajı verilir. Bunlardan hiçbiri arzu edilmez, bu yüzden rwdevam etmeden önce bölümümün modda monte edilip edilmediğini kontrol ediyorum .

NOT 2015-03-03 Sabit bağlantıları doğru şekilde kopyalamak için cevabımı değiştirdim. Orijinal işe yaradı, ancak pek çok hardlink'i dosyalara dönüştürdü. Harcanan boşluğa ek olarak, bu, sabit bağlantıların yerinde olduğunu varsayan birçok kullanımdan ödün verir. (Şu andaki görüntüm Raspbian'ın kendisinde 869 bağlantı içeriyor.)

Bunu yapmak için benim komut dosyası izler. ( PiDataBölümüm üzerine monte edildi/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

Aşağıdakilerle geri yükleyin (veya başka bir Pi'yi güncelleyin): -

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

rsync-exclude.txtGereksiz dosyaları ortadan kaldırmak için geliştirdim .

İlk grup, @goldilocks https://raspberrypi.stackexchange.com/users/5538/ tarafından belgelenen dizinlerdir.

İkinci grup, PiP'ye AFP (Apple Dosyalama Protokolü) kullanarak eriştiğimde OS X tarafından oluşturulan dosyalar ve dizinlerdir. (Bunlar normalde OS X'te görünmez, ancak Raspbian'da değil. Her durumda, yedeklemeye gerek yoktur.) AFP kullanmasanız bile, bunlar zarar vermez.

Üçüncü grup, yedeklenmesi gerekmeyen (ve kesinlikle başka bir Pi'ye kopyalanmayan) dosyalardır. Örnekler sahte-hwclock.data, RPi-Monitor raporları. Muhtemelen başkalarına sahip olacaksın.

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

Yerel ağımda çalışan üç Pis'e sahibim ve çalışırken ve çalışırken cron ile düzenli bir şekilde onları yedeklemem gerekiyor. Bu yüzden dd, tar ve rsync yedekleri yaratabilen ve onları geri yükleyebilen bir komut dosyası oluşturdum. Yedeklerim için rsync kullanmayı tercih ediyorum, ancak diğer insanlar dd veya tar'yı tercih ediyor. Zaten birçok kişi tarafından kullanılıyor. Umarım diğerleri için de yararlıdır :-) raspibackup - Ahududu kendi yedeğini oluşturur

İşte böyle amaçlar için kararlı bir araçtır: https://github.com/aktos-io/aktos-dcs-tools

Bu araç yazılır make sshbağlantıları make backup-root, make mount-rootuzaktan ilk başta akılda yerlerde ve sonra yerel oturumlar eklenir dan. Bu yüzden yerel yedeklemeleri, doğrudan uzaktan yedeklemeleri, proxy uzaktan yedeklemeleri destekler. Yedeklemeler artımlı olarak alınır (yalnızca farklar aktarılır) ve yedekleme dizinleri bağımsızdır (geri yüklemek için bir dizin / sürüm seçin, herhangi bir dizinin tam yedeği vardır). Tabii ki, sürümleri var (backup.last-0 en yenisidir). İstediğiniz zaman yedekleme işlemini durdurabilir ve daha sonra devam edebilirsiniz.

Özel sorununuz için talimatlar:

 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

DÜZENLE

Şimdi yeni bir hedef eklendi: Bir komutla yedeklemelerinizden fiziksel bir SD Kart oluşturabilirsiniz:

make create-disk-from-last-backup

Talimatları takip edin, SD Kartınızı oluşturun, RaspberryPi'yi yeni oluşturulan bu SD Kart ile önyükleyin.

İşte tamamen farklı bir yaklaşım. Sen kullanabilirsiniz LVM ( L ogical V olume M tutarlı yedeklemeler yapmak anager). Kolay ekleme, genişletme ve azaltma ya da işletim sistemini anlık görüntüden daha önceki bir duruma geri yükleme gibi diğer geliştirmelerin yanı sıra yedeklemeler de yapabilirsiniz. Yedekleme sırasında dinamik olarak değiştirilmiş dosyalar hakkında endişe duymazsınız, sadece dosya sistemlerini okumak, belirli dizinleri veya başka şeyleri hariç tutarsınız. LVM ile, sadece bir anlık görüntü oluşturursunuz, bu anlık görüntüyü bağlar ve tercih ettiğiniz yöntemle yedeklersiniz. İle kopya cp -ayapabilir, ayna ile ayna rsyncyapabilir, arşiv taryapabilir veya resim ile oluşturabilirsiniz.dd. Üzerine bir yedekleme aygıtı taktığınızı varsayarak /mnt/usbhd/pi_backup/, örneğin:

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

LVM kurulumu sadece bir kez biraz zaman alır . Bunu nasıl yapabilirsiniz LVM ile çalışan bir sistemin Kolay yedekleme ve anlık görüntülerine bakabilirsiniz .

Yüklenebilir görüntüler yapan bir yedekleme aracı buldum .

Ayrıca görüntüleri monte etmek ve daraltmak için yardımcı programları da vardır.

Bu başkaları için faydalı olabilir

Birlikte verilen belgeler çok kısa, bu yüzden aşağıdakilere dikkat edin: -

1. Yardımcı programları herhangi bir dizine çıkartın ve komut dosyalarını çalıştırılabilir duruma getirin.
2. Pi'nize ext4biçimlendirilmiş bir bölüm yerleştirin /mntveya /media(büyük dosyalara izin veren ve Pi tarafından desteklenen herhangi bir biçim, örneğin exFAT veya bir ağ sürücüsü kullanılabilir).
3. İlk çalıştırmada sizden örneğin bir Yedek İmaj adı istenecek /mnt/Image/BusterBackup.img
4. Bir Image ROOT dosya sistemi boyutu (MB cinsinden) istenir, bu mümkün olan en küçükler için 0 olabilir veya tam yedekleme için boş olabilir.
5. Sonraki çalıştırmalarda, artımlı olarak güncellenecek Yedek İmajın yolunu girin.

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"

Bölüm ofsetlerini ve boyutlarını doğru bir şekilde hesaplamak için orijinali (montaj noktalarını kopyalamak için) biraz değiştirdim ve birkaç yorum ekledim.

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

Terminali açın ve 'lsblk -f' yazın.
Bu, bağlı tüm depolama cihazlarını göstermelidir.
Ardından 'dd if = / dev / [sd kartınızın ADI] bs = 1M' yazın.
Bu biraz zaman alacaktır, böylece arka planda çalıştırmak isteyebilirsiniz.
Bu, sd kartınızı Linux'ta yedeklemenizin tam yoludur.