हार्ड डिस्क के वृद्धिशील स्नैपशॉट बनाने और पुनर्स्थापित करने के लिए कैसे


13

मैं डिस्ट्रो / एप्लिकेशन परीक्षण उद्देश्यों के लिए वर्चुअल बॉक्स का उपयोग करता हूं।

सुविधाओं में से एक मुझे बस इसके बारे में प्यार है आभासी मशीनें स्नैपशॉट हैं, यह एक आभासी मशीन की एक स्थिति को बचाता है और इसे अपने पूर्व गौरव में पुनर्स्थापित करने में सक्षम है यदि आपने कुछ भी बिना किसी समस्या के गलत किया और अपने सभी हार्ड डिस्क स्थान का उपभोग किए बिना।

मेरे लाइव सिस्टम पर मुझे पता है कि फाइल सिस्टम का 1: 1 इमेज कैसे बनाया जाता है, लेकिन सभी समाधान जिन्हें मैं जानता हूं, वे पूरी फाइल सिस्टम की एक नई इमेज बनाएंगे।

क्या ऐसे कोई प्रोग्राम / फाइल सिस्टम हैं जो वर्तमान फ़ाइल सिस्टम का स्नैपशॉट लेने में सक्षम हैं, इसे किसी अन्य स्थान पर सहेज सकते हैं लेकिन एक पूर्ण नई छवि बनाने के बजाय यह वृद्धिशील बैकअप बनाता है?

यह वर्णन करने के लिए कि मुझे क्या चाहिए, यह ddएक फ़ाइल सिस्टम की छवियों के रूप में होना चाहिए , लेकिन केवल एक पूर्ण बैकअप के बजाय यह वृद्धिशील भी पैदा करेगा।


मैं क्लोनज़िला की तलाश नहीं कर रहा हूं, आदि। इसे सिस्टम से उपयोगकर्ता के बिना (या लगभग कोई नहीं) हस्तक्षेप के साथ चलना चाहिए, लेकिन फ़ाइल सिस्टम के सभी डेटा शामिल हैं। मैं आपके mbr को बचाने के लिए duplicityकुछ फ़ोल्डर्स स्क्रिप्ट + ddको छोड़कर आपके सभी सिस्टम बैकअप की तलाश में नहीं हूं । मैं खुद ऐसा कर सकता हूं, अतिरिक्त चालाकी की तलाश कर रहा हूं।

मैं एक ऐसी चीज की तलाश कर रहा हूं, जिसे मैं सिस्टम में बड़े पैमाने पर बदलाव करने से पहले कर सकता हूं और फिर अगर कुछ गलत हो या मैंने अपनी हार्ड डिस्क को कॉफ़ी को जलाने के बाद जला दिया हो तो मैं सिर्फ एक लाइवसीडी से बूट कर सकता हूं और एक हार्ड डिस्क में काम करने वाले स्नैपशॉट को पुनर्स्थापित कर सकता हूं।

यह दैनिक होने की जरूरत नहीं है, यह भी एक कार्यक्रम की जरूरत नहीं है। बस एक बार चलाएं और इसे अपना काम करने दें और अधिमानतः रॉ आधारित फ़ाइल कॉपी आधारित न हो।



तो, आप एक ऐसे एप्लिकेशन की तलाश कर रहे हैं जो इंस्टॉल करने योग्य चित्र बना सके? यदि नहीं, तो आप Deja Dup क्यों पसंद नहीं करते? यदि आप एक आवेदन पूछ रहे हैं, तो मैं उस उत्तर को भी जानना चाहता हूं जो स्थापित करने योग्य चित्र बना सकता है। पसंदीदा जोड़ना।
दिलकशी

शीर्षक के रूप में प्रश्न का उत्तर पोस्ट किया गया ... लेकिन मैं देख रहा हूं कि आप एक फ़ाइल स्तर के बजाय अपने सिस्टम नंगे धातु को पुनर्स्थापित करने के लिए एक संभावित तरीके की तलाश कर रहे हैं।
cprofitt

1
ऐसा लगता है कि आप ब्लॉक स्तर चाहते हैं, फाइल सिस्टम नहीं, वृद्धिशील बैकअप। स्नैपशॉट का समर्थन करने वाली फ़ाइल सिस्टम से परे मुझे यकीन नहीं है कि अगर आप पूछ रहे हैं तो क्या संभव है। LVM, BTRFS एक संभावना हो सकती है।
cprofitt

शीर्षक को ठीक करने के लिए @cprofitt thx, यह अधिक सही है।
ब्रूनो परेरा

@ ब्रूनो - अच्छे शीर्षक बनाने से उत्तर खोजने के लिए आने वाले लोगों के लिए इसे उपयोगी बनाने में मदद मिलती है।
cprofitt

जवाबों:


14

व्याख्या करने के लिए cprofitt के जवाब (के रूप में अपने जवाब है , वृद्धिशील के रूप में मैं समझा जाएगा) ...

सबसे पहले आपको हार्ड लिंक के बारे में जानना होगा।

हार्ड लिंक उस डेटा की ओर इशारा करते हैं जो वास्तव में डिस्क (भौतिक स्थान) पर है और आप हार्ड लिंक का उपयोग करके डेटा तक पहुंच सकते हैं। प्रत्येक फ़ाइल और निर्देशिका भौतिक डिस्क पर डेटा के स्थान के लिए एक कड़ी है। इसलिए यदि एक ही स्थान की ओर इशारा करते हुए दो फाइलें (हार्ड लिंक) हैं तो डेटा केवल एक बार संग्रहीत किया जाता है


Cprofitt द्वारा दी गई प्रक्रिया में शामिल हैं:

  1. एक नए के लिए एक स्थान बनाने के लिए बैकअप घुमाएँ। (कल से "आज का बैकअप" "कल का बैकअप" बन जाता है, "कल का बैकअप" दो दिन पहले से "दो दिन पहले का बैकअप" और इसी तरह)

    • जब तक आप चाहते हैं तब तक यह सूची बढ़ती रहती है, हालांकि स्क्रिप्ट में केवल 4 स्नैपशॉट हैं। (यह अगले स्तर के लिए पूरी प्रक्रिया को फिर से करता है (जैसे एक सप्ताह - "इस सप्ताह का बैकअप") और उन लोगों को घुमाता है, इसलिए यह केवल 4 है।
    • ओवरराइटिंग को रोकने के लिए मूविंग रिवर्स में किया जाता है
  2. आपके द्वारा किए गए नवीनतम स्नैपशॉट की प्रतिलिपि बनाएँ (जैसे "कल का बैकअप") नए के लिए स्पॉट पर (जैसे "आज का बैकअप"), फ़ाइल की प्रतिलिपि के बिना मौजूदा फ़ाइलों के लिए नए हार्ड लिंक बनाना। इसलिए नए स्नैपशॉट की सभी फाइलें पिछले एक के समान स्थान की ओर इशारा करती हैं ।


एक सचित्र उदाहरण

नीचे दी गई तस्वीर में, एक ही रंग के फ़ाइल जिनमें समान फ़ाइल नाम है, डिस्क पर एक ही फ़ाइल के हार्ड लिंक हैं। यहां हम केवल दो स्नैपशॉट और कुछ फ़ाइलों के साथ काम कर रहे हैं, लेकिन उदाहरण तराजू। (इस तथ्य को छोड़कर कि मैं स्नैपशॉट को cproffit के उत्तर में लिपियों के विपरीत तरीके से आगे बढ़ा रहा हूं)

यहाँ छवि विवरण दर्ज करें

प्रक्रिया यह है:

  1. सिस्टम का एक स्नैपशॉट है।

  2. स्नैपशॉट प्रतियां हैं (मौजूदा फ़ाइलों के लिए कड़ी बनाना)

  3. स्नैपशॉट को अपडेट करने के लिए रुपीस चलाया जाता है। जब फाइलें बदली जाती हैं, तो यह नई फाइल को हार्ड डिस्क पर एक नई प्रति के रूप में संग्रहीत करता है (इसलिए पुराने स्नैपशॉट को बदला नहीं जाता है)। इस उदाहरण में, फ़ाइल B को बदल दिया गया है। नोट: अब हमारे पास फ़ाइल A और फ़ाइल C की केवल 1 प्रति और हार्ड डिस्क पर संग्रहीत फ़ाइल B की दो प्रतियां हैं

  4. स्नैपशॉट को घुमाएँ (इस स्थिति में स्नैपशॉट 0 'बंद हो जाता है' और हटा दिया जाता है और मैं स्नैपशॉट 1 का नाम बदलकर स्नैपशॉट 0 कर देता हूँ)

  5. स्नैपशॉट एगिन को कॉपी करें (चरण 2 का दोहराव)

  6. रुपये फिर से। (चरण 3 का दोहराव)। अब हमारे पास फाइल A की 1 कॉपी और फाइल B और फाइल C दोनों की 2 प्रतियां हैं


[पहले] स्क्रिप्ट का एक सरलीकृत संस्करण (चलाने के लिए नहीं, बस एक कदम पत्थर के रूप में) यह है:

#!/bin/bash

# Delete the snapshot we don't want (has 'fallen off')
rm -rf /root/snapshot/home/hourly.3 ;

# Rotate the snapshots by shuffling them back
mv /root/snapshot/home/hourly.2 /root/snapshot/home/hourly.3 ;
mv /root/snapshot/home/hourly.1 /root/snapshot/home/hourly.2 ;

# Copy the snapshot (creating hard links to the existing files)
cp -al /root/snapshot/home/hourly.0 /root/snapshot/home/hourly.1 ;

# Do the rsync ...
# step 4: rsync from the system into the latest snapshot (notice that
# rsync behaves like cp --remove-destination by default, so the destination
# is unlinked first.  If it were not so, this would copy over the other
# snapshot(s) too!
rsync -va --delete /home/ /root/snapshot/home/hourly.0 ;

अब पूर्ण स्क्रिप्ट (एस) का यहां पूर्ण विवरण है (जैसा कि cprofitt से जुड़ा हुआ है) और यह पूरी तरह से अधिक है लेकिन यह मूल रूप से ऊपर है। दूसरी स्क्रिप्ट स्नैपशॉट को समूहीकृत करने के लिए है और प्रक्रिया के स्वचालित होने (क्रोन का उपयोग करने) के बारे में cprofitt के उत्तर वार्ता का दूसरा हिस्सा है और यह पुष्टि करते हुए कि बैकअप पर्याप्त था।

आप नाम बदल सकते हैं, इसलिए निर्देशिकाओं के बजाय "प्रति घंटा ..." कहा जा रहा है और उन्हें कुछ और कहा जाता है और स्क्रिप्ट को मैन्युअल रूप से चलाया जाता है।


पूरे लॉट को रिस्टोर करने के लिए, उस लेटेस्ट स्नैपशॉट (या पिछले वाले) को उस डायरेक्टरी में वापस कॉपी करें जिसे आप बैकअप ले रहे थे।

किसी एकल फ़ाइल को जो अभी भी स्नैपशॉट में है, को पुनर्स्थापित करने के लिए, स्नैपशॉट पर जाएं और इसे वापस उसी स्थान पर कॉपी करें जहां यह है।

बैकअप मीडिया एक बाहरी हार्ड ड्राइव (ext2 / ext3 / ext4 होना चाहिए) हो सकता है। यदि आप /(मुख्य रूप /bootसे /home, /etc /rootऔर /usr) समर्थन कर रहे थे , तो कहें ...

  1. आप बाहरी ड्राइव को माउंट करते हैं, बैकअप करते हैं और नवीनतम स्नैपशॉट बनाते हैं।

  2. ड्राइव को अनमाउंट करें।

  3. याद रखें कि आपने एक फ़ाइल (कूड़े से भी) हटाई थी जो आप चाहते थे।

  4. बाहरी ड्राइव कनेक्ट करें और फ़ाइल पुनर्प्राप्त करें।

  5. एक बैकअप करें (बस सुनिश्चित करें)

  6. ड्राइव डिस्कनेक्ट करें और यात्रा करें ...

  7. एहसास है कि एक लैपटॉप और लावा मिश्रण नहीं है।

  8. अपने नए लैपटॉप में एक लाइव सीडी चलाने के साथ, आंतरिक ड्राइव को प्रारूपित करें, आप बाहरी ड्राइव को माउंट करें और फिर cp -a /media/external/snapshot-0/* /media/internal-drive(स्नैपशॉट-0 नवीनतम स्नैपशॉट मानकर)

  9. एमबीआर को ग्रब स्थापित करें (हाँ, इसे अलग करना होगा) - या ddमलबे का बैकअप लेने के लिए उपयोग करें, जैसे कि उनके जवाब के नीचे cprofitt ने कहा है।

  10. रीबूट।

स्क्रिप्ट को परिष्कृत करने की आवश्यकता है (केवल वही सामान प्राप्त करना है जो आप चाहते हैं) और प्रक्रिया एओवी मानती है कि आपके पास /homeविभाजन नहीं है । यदि आप करते हैं (या था) डिस्क पर एक नया बनाएं और mount /dev/sdxy /media/external/homeकॉपी करने से पहले इसे माउंट करें ।


100 dd स्नैपशॉट 100 x <average size of snapshot> में डिस्क स्थान की कीमत होगी । इनमें से 100 पर खर्च होगा <size of snapshot> + <size of changed files>। मैंने इसका उपयोग 500GB डिस्क पर / home (~ 400GB) के कई स्नैपशॉट लगाने के लिए किया है।
पोर्टेबलजिम

आप अपने फाइल सिस्टम पर वर्चुअल डिस्क छवि को माउंट कर सकते हैं, फिर उसी का बैकअप ले सकते हैं। देखें superuser.com/questions/158908/... और लिंक
Portablejim

जैसा कहा गया है, यह मेरे चलने वाले कंप्यूटरों के लिए है, न कि एक आभासी बॉक्स के लिए, vbox सिर्फ एक उदाहरण था।
ब्रूनो परेरा

अपडेटेड प्रश्न (टिप्पणी जोड़ने के बजाय अंत में)।
पोर्टेबलजिम

@Portablejim: आप लिख रहे हैं कि cp "हार्ड लिंक्स को संरक्षित करना" है। मुझे लगता है कि यह वाक्यांश भ्रामक है। cp -alस्रोत फ़ाइलों की प्रतिलिपि बनाने के बजाय स्रोत फ़ाइलों को हार्डलिंक बना रहा है। आपके आंकड़े भी दर्शाते हैं, उदाहरण के लिए कि चित्र 2 में ए फाइलें एक ही फाइल है।
daniel kullmann

7

आप rsync का उपयोग कर सकते हैं।

Listing one: make_snapshot.sh

#!/bin/bash
# ----------------------------------------------------------------------
# mikes handy rotating-filesystem-snapshot utility
# ----------------------------------------------------------------------
# this needs to be a lot more general, but the basic idea is it makes
# rotating backup-snapshots of /home whenever called
# ----------------------------------------------------------------------

unset PATH  # suggestion from H. Milz: avoid accidental use of $PATH

# ------------- system commands used by this script --------------------
ID=/usr/bin/id;
ECHO=/bin/echo;

MOUNT=/bin/mount;
RM=/bin/rm;
MV=/bin/mv;
CP=/bin/cp;
TOUCH=/bin/touch;

RSYNC=/usr/bin/rsync;


# ------------- file locations -----------------------------------------

MOUNT_DEVICE=/dev/hdb1;
SNAPSHOT_RW=/root/snapshot;
EXCLUDES=/usr/local/etc/backup_exclude;


# ------------- the script itself --------------------------------------

# make sure we're running as root
if (( `$ID -u` != 0 )); then { $ECHO "Sorry, must be root.  Exiting..."; exit; } fi

# attempt to remount the RW mount point as RW; else abort
$MOUNT -o remount,rw $MOUNT_DEVICE $SNAPSHOT_RW ;
if (( $? )); then
{
    $ECHO "snapshot: could not remount $SNAPSHOT_RW readwrite";
    exit;
}
fi;


# rotating snapshots of /home (fixme: this should be more general)

# step 1: delete the oldest snapshot, if it exists:
if [ -d $SNAPSHOT_RW/home/hourly.3 ] ; then         \
$RM -rf $SNAPSHOT_RW/home/hourly.3 ;                \
fi ;

# step 2: shift the middle snapshots(s) back by one, if they exist
if [ -d $SNAPSHOT_RW/home/hourly.2 ] ; then         \
$MV $SNAPSHOT_RW/home/hourly.2 $SNAPSHOT_RW/home/hourly.3 ; \
fi;
if [ -d $SNAPSHOT_RW/home/hourly.1 ] ; then         \
$MV $SNAPSHOT_RW/home/hourly.1 $SNAPSHOT_RW/home/hourly.2 ; \
fi;

# step 3: make a hard-link-only (except for dirs) copy of the latest snapshot,
# if that exists
if [ -d $SNAPSHOT_RW/home/hourly.0 ] ; then         \
$CP -al $SNAPSHOT_RW/home/hourly.0 $SNAPSHOT_RW/home/hourly.1 ; \
fi;

# step 4: rsync from the system into the latest snapshot (notice that
# rsync behaves like cp --remove-destination by default, so the destination
# is unlinked first.  If it were not so, this would copy over the other
# snapshot(s) too!
$RSYNC                              \
    -va --delete --delete-excluded              \
    --exclude-from="$EXCLUDES"              \
    /home/ $SNAPSHOT_RW/home/hourly.0 ;

# step 5: update the mtime of hourly.0 to reflect the snapshot time
$TOUCH $SNAPSHOT_RW/home/hourly.0 ;

# and thats it for home.

# now remount the RW snapshot mountpoint as readonly

$MOUNT -o remount,ro $MOUNT_DEVICE $SNAPSHOT_RW ;
if (( $? )); then
{
    $ECHO "snapshot: could not remount $SNAPSHOT_RW readonly";
    exit;
} fi;

और दूसरा:

Listing two: daily_snapshot_rotate.sh

#!/bin/bash
# ----------------------------------------------------------------------
# mikes handy rotating-filesystem-snapshot utility: daily snapshots
# ----------------------------------------------------------------------
# intended to be run daily as a cron job when hourly.3 contains the
# midnight (or whenever you want) snapshot; say, 13:00 for 4-hour snapshots.
# ----------------------------------------------------------------------

unset PATH

# ------------- system commands used by this script --------------------
ID=/usr/bin/id;
ECHO=/bin/echo;

MOUNT=/bin/mount;
RM=/bin/rm;
MV=/bin/mv;
CP=/bin/cp;

# ------------- file locations -----------------------------------------

MOUNT_DEVICE=/dev/hdb1;
SNAPSHOT_RW=/root/snapshot;

# ------------- the script itself --------------------------------------

# make sure we're running as root
if (( `$ID -u` != 0 )); then { $ECHO "Sorry, must be root.  Exiting..."; exit; } fi

# attempt to remount the RW mount point as RW; else abort
$MOUNT -o remount,rw $MOUNT_DEVICE $SNAPSHOT_RW ;
if (( $? )); then
{
    $ECHO "snapshot: could not remount $SNAPSHOT_RW readwrite";
    exit;
}
fi;


# step 1: delete the oldest snapshot, if it exists:
if [ -d $SNAPSHOT_RW/home/daily.2 ] ; then          \
$RM -rf $SNAPSHOT_RW/home/daily.2 ;             \
fi ;

# step 2: shift the middle snapshots(s) back by one, if they exist
if [ -d $SNAPSHOT_RW/home/daily.1 ] ; then          \
$MV $SNAPSHOT_RW/home/daily.1 $SNAPSHOT_RW/home/daily.2 ;   \
fi;
if [ -d $SNAPSHOT_RW/home/daily.0 ] ; then          \
$MV $SNAPSHOT_RW/home/daily.0 $SNAPSHOT_RW/home/daily.1;    \
fi;

# step 3: make a hard-link-only (except for dirs) copy of
# hourly.3, assuming that exists, into daily.0
if [ -d $SNAPSHOT_RW/home/hourly.3 ] ; then         \
$CP -al $SNAPSHOT_RW/home/hourly.3 $SNAPSHOT_RW/home/daily.0 ;  \
fi;

# note: do *not* update the mtime of daily.0; it will reflect
# when hourly.3 was made, which should be correct.

# now remount the RW snapshot mountpoint as readonly

$MOUNT -o remount,ro $MOUNT_DEVICE $SNAPSHOT_RW ;
if (( $? )); then
{
    $ECHO "snapshot: could not remount $SNAPSHOT_RW readonly";
    exit;
} fi;

अपनी आवश्यकताओं के लिए स्क्रिप्ट बनाने के बाद इसे क्रोन नौकरियों में जोड़ें।

Crontab -e

निम्नलिखित जोड़ें:

0 * / 4 * * * /usr /local/bin/make_snapshot.sh

० १३ * * * * /rr/local/bin/daily_snapshot_rotate.sh

वे make_snapshot.sh को हर चार घंटे पर और दैनिक_snapshot_rotate.sh को हर दिन 13:00 (यानी, 1:00 PM) पर चलाने का कारण बनाते हैं।

स्रोत: http://www.mikerubel.org/ computers/ rsync_snapshots/

* * * * * command to be executed
- - - - -
| | | | |
| | | | ----- Day of week (0 - 7) (Sunday=0 or 7)
| | | ------- Month (1 - 12)
| | --------- Day of month (1 - 31)
| ----------- Hour (0 - 23)
------------- Minute (0 - 59)

यदि आप चाहते हैं कि यह प्रति घंटा चले तो आप प्रत्येक घंटे के लिए क्रोन की नौकरी जोड़ देंगे।

एक अन्य संभावित विकल्प rsnapshot का उपयोग कर रहा है

  1. Rsnapshot स्थापित करें (सॉफ्टवेयर केंद्र में उपलब्ध)

  2. Rsnapshot कॉन्फ़िगर करें और बैकअप स्रोत निर्देशिका निर्दिष्ट करें

/Etc/rsnapshot.conf को खोलें और निम्न पंक्तियों को अनलिमिटेड करें।

# nano /etc/rsnapshot.conf

cmd_cp          /bin/cp
cmd_ssh /usr/bin/ssh
cmd_du          /usr/bin/du
cmd_rsnapshot_diff      /usr/local/bin/rsnapshot-diff
logfile /var/log/rsnapshot
  1. नीचे दिखाए गए अनुसार अपनी गंतव्य निर्देशिकाओं को /etc/rsnapshot.conf में परिभाषित करें। इस उदाहरण में,

    / होम - स्रोत निर्देशिका जो बैकअप-संग्रहित की जाएगी, स्थानीय बैकअप / - गंतव्य निर्देशिका का बैकअप होना चाहिए। कृपया ध्यान दें कि यह निर्देशिका अंतिम चरण में दिखाए गए अनुसार /.snapshots/ellinginternal.narios/ निर्देशिका के तहत बनाई जाएगी।

    नैनो /etc/rsnapshot.conf

    बैकअप / घर / लोकलहोस्ट /

  2. Rsnapshot कॉन्फ़िगरेशन का परीक्षण करें

सुनिश्चित करें कि rsnapshot सेटअप ठीक से तैयार है और linux rsync बैकअप करने के लिए तैयार है, इसके लिए कॉन्फ़िगरेशन टेस्ट करें।

# rsnapshot configtest
Syntax OK
  1. Rsnapshot प्रति घंटा बैकअप कॉन्फ़िगरेशन की जाँच करें

आप विभिन्न अंतराल पर लिनक्स निर्देशिकाओं या फ़ाइलों का बैकअप ले सकते हैं। डिफ़ॉल्ट रूप से, प्रति घंटा और दैनिक बैकअप कॉन्फ़िगर किए जाते हैं।

प्रति घंटा बैकअप कॉन्फ़िगरेशन की जाँच करें।

# rsnapshot -t hourly
echo 6490 > /var/run/rsnapshot.pid
mkdir -m 0700 -p /.snapshots/
mkdir -m 0755 -p /.snapshots/hourly.0/
/usr/bin/rsync -a --delete --numeric-ids --relative --delete-excluded /home \
/.snapshots/hourly.0/localhost/
mkdir -m 0755 -p /.snapshots/hourly.0/
/usr/bin/rsync -a --delete --numeric-ids --relative --delete-excluded /etc \
/.snapshots/hourly.0/localhost/
mkdir -m 0755 -p /.snapshots/hourly.0/
/usr/bin/rsync -a --delete --numeric-ids --relative --delete-excluded \
/usr/local /.snapshots/hourly.0/localhost/
touch /.snapshots/hourly.0/
  1. Rsnapshot दैनिक बैकअप कॉन्फ़िगरेशन सत्यापित करें

सत्यापित करें कि दैनिक rsnapshot cwrsync बैकअप प्रक्रिया ठीक से कॉन्फ़िगर की गई है।

# rsnapshot -t daily
echo 6493 > /var/run/rsnapshot.pid
mkdir -m 0700 -p /.snapshots/
/.snapshots/hourly.5 not present (yet), nothing to copy
  1. Rsnapshot के लिए Crontab Entry जोड़ें

एक बार जब आप यह सत्यापित कर लेते हैं कि rsnapshot cwrsync उपयोगिता में rsync प्रति घंटा और दैनिक बैकअप कॉन्फ़िगरेशन ठीक से सेटअप हैं, तो नीचे दिखाए गए अनुसार इस पिल्ला को crontab में सेट करने का समय है।

# crontab -e
0 */4 * * * /usr/local/bin/rsnapshot hourly
30 23 * * * /usr/local/bin/rsnapshot daily

स्रोत: http://www.thegeekstuff.com/2009/08/tutorial-backup-linux-using-rsnapshot-rsync-utility/

---- नंगे धातु की वसूली

मैं डीडी और टार का उपयोग नंगेपन की वसूली के लिए करूंगा।

बैकअप महत्वपूर्ण मेटाडेटा:

# dd if-/dev/hda of=/backups/mbr bs=512 count=1

ऑपरेटिंग सिस्टम का बैकअप लें:

# mkdir /backups
# mount nfsserver:/backups/<servername> /backups


# cd /
# tar cfz /backups/system.tar.gz --exclude /mnt --exclude /proc --exclude /backups

मैं व्यक्तिगत रूप से अपने सिस्टम को ऑफ-लाइन लेना चाहूंगा, अगर मैं एक बेयरमेटल रिस्टोर फाइल बनाना चाहता हूं।


2
आपके सभी उत्तर बहुत अच्छे लगते हैं, कोई समस्या नहीं है और यह सब नहीं है, लेकिन मैं जो पूछ रहा हूं, उसमें से कोई भी तरीका एमबीआर को बहाल नहीं करेगा और ddवेतन वृद्धि नहीं है। यह कोई नहीं है जो मैं पूछ रहा हूं। अंतिम 10% के लिए देखना दिलचस्प हो सकता है लेकिन बाकी सभी जानकारी डंप वास्तव में नहीं है।
ब्रूनो परेरा

फ़ाइल सिस्टम (एक फ़ाइल सिस्टम के रूप में) के साथ उपरोक्त विवरण और मैंने एमबीआर से निपटने के लिए dd प्रक्रिया को जोड़ा।
cprofitt

3

ब्लॉक आधारित वृद्धिशील बैकअप करने के 2 तरीके हैं

  • फाइलसिस्टम आधारित स्नैपशॉट
  • कार्यक्रम आधारित स्नैपशॉट

फाइलसिस्टम आधारित स्नैपशॉट

ZFS और BTRFS दोनों ब्लॉक आधारित वृद्धिशील स्नैपशॉट प्रदान करते हैं ( BTRFS , ZFS (पृष्ठ 25) )। आपके पास एक ड्राइव हो सकती है जिसे आप rsync करते हैं या तो ZFS या BTRFS और स्नैपशॉट।

वहाँ भी है एलवीएम स्नैपशॉट (cprofitt ने उल्लेख किया) है कि एक ही ब्लॉक आधारित वृद्धिशील स्नैपशॉट प्रदान करते हैं।

कार्यक्रम आधारित स्नैपशॉट

वहाँ कई बैकअप कार्यक्रम , हालांकि कुछ उद्देश्य के लिए बाहर रहना:

मुझे पता है कि आपने विशेष रूप से उल्लेख किया है कि आप नकल जैसी किसी चीज की तलाश नहीं कर रहे हैं, हालांकि मैंने सोचा कि मैं कुछ विशेषताओं का उल्लेख कर सकता हूं।

हालांकि इन कार्यक्रमों को पुनर्स्थापित करने के लिए आपको उन्हें स्थापित करने की आवश्यकता होती है। Rsync जैसी किसी चीज़ की सुंदरता यह है कि लगभग हर लिनक्स इंस्टॉलेशन में rsync है (उदाहरण के लिए छोटे कोर (10MB वितरण) इसे गायब है) डिफ़ॉल्ट रूप से।

कपट

यह केवल अंतर (ब्लॉक स्तर) को संग्रहीत करता है और फिर उन्हें संपीड़ित और एन्क्रिप्ट करता है। यह rsync विधि की तुलना में और भी कम संग्रहण की ओर जाता है, हालाँकि (कम से कम जिस तरह से मैं इसे देखता हूं) फाइलसिस्टम को फिर से संगठित करने की आवश्यकता होगी, जिसमें समय लगेगा (यदि आप इसके साथ वृद्धिशील बैकअप का उपयोग कर रहे हैं, और यह उस समय से निर्भर करता है अंतिम पूर्ण बैकअप)

आदमी पेज बताते हैं कि यह कैसे काम करता है।

Rdiff-बैकअप

एक क्लाइंट-सर्वर प्रोग्राम जो बनाता है, जैसे कि द्वैधता, ब्लॉक स्तर भिन्न होता है, हालांकि यह अंतिम पुनर्स्थापना बिंदु से परिवर्तनों को संग्रहीत करता है, इसलिए नवीनतम स्नैपशॉट पुनर्स्थापित करने के लिए सबसे तेज़ है। समय में वापस जा रहे हैं (नवीनतम स्नैपशॉट नहीं) का विश्लेषण करने के लिए अधिक भिन्नता की आवश्यकता होती है और इसलिए यह धीमा है।

कुछ लोग rdiff-backup की तुलना rsnapshot से करते हैं (ऐसा लगता है कि rsync मेंट का अधिक स्वचालित तरीका है)। लगभग सभी कैसे नेटवर्क पर rdiff का उपयोग करने पर ध्यान केंद्रित करते हैं, हालांकि मुझे एक मिला है जिसमें स्थानीयहोस्ट पर इसे करने का उल्लेख है ।


ठीक है मुझे यह पसंद है, यह वर्णन करने के लिए कि विभाजन को बहाल करने के साथ कैसे काम करें? यानी, अगर मैं एक डिस्क को तोड़ता हूं, तो मैं एक स्नैपशॉट से अपने पूर्ण सिस्टम को कैसे पुनर्स्थापित करूँगा, जिसमें विभाजन को स्वयं बनाने के लिए, आदि बहुत विस्तृत नहीं हैं या स्क्रिप्ट शामिल हैं, बस कुछ कमांड नाम और वे क्या करेंगे।
ब्रूनो परेरा

मुझे इन प्रणालियों के साथ अनुभव नहीं था, मैंने केवल Google का उपयोग करके कुछ शोध करने से पाया था (इसलिए वे केवल लिंक क्यों हैं)। उदाहरण के लिए मैंने सीखा कि duplicityवास्तव में क्या है।
पोर्टेबलजिम

3

आपको ddar ( होमपेज ) पर एक नज़र रखना चाहिए ।

यह स्नैपशॉट के समान भागों को स्थानांतरित नहीं करने के अर्थ में वृद्धिशील है। यह शब्द के शास्त्रीय अर्थ में वृद्धिशील नहीं है, क्योंकि यह स्नैपशॉट के साथ काम कर रहा है।

नोट: मैंने खुद यह कोशिश नहीं की है (लेकिन मुझे लेखक पर भरोसा है)। यह वह नहीं कर सकता जो आप आउट-ऑफ-द-बॉक्स प्राप्त करना चाहते हैं, लेकिन फिर भी पृष्ठ पर अधिक समान समाधान हैं (उदाहरण। ZFS ), इसलिए एक प्रारंभिक बिंदु के रूप में, यह संभवतः उपयोगी साबित हो सकता है।


1
मैं ddar (उल्लेख के लिए धन्यवाद!) का लेखक हूं। अगर मैं प्रश्न को सही ढंग से समझूं तो ddar को LVM स्नैपशॉट की एक श्रृंखला सौंपना बिल्कुल अनुरोध के रूप में करना होगा। जैसा कि आप कहते हैं, यह वृद्धिशील के बजाय स्नैपशॉट से संबंधित है, लेकिन स्नैपशॉट का लाभ के साथ एक ही प्रभाव होगा कि पुराने स्नैपशॉट को नए लोगों को प्रभावित किए बिना हटाया जा सकता है।
रॉबी बसाक

@robie मुझे यह देखने के लिए तैयार किया जाएगा कि यह कैसे काम करेगा, क्या आप मेरे लिए या किसी भी उपयोगकर्ता के लिए एक बहुत छोटा गाइड बना सकते हैं जो इस तरह के समाधान की तलाश में है?
ब्रूनो परेरा

1

मुझे लगता है कि आप LVM के साथ इसका एकमात्र सिद्धांत कर सकते हैं, और यह हार्ड डिस्क की एक बड़ी राशि बर्बाद कर देगा। मेरा सिद्धांत यह है कि आप अपने रूट सिस्टम को लॉजिकल वॉल्यूम पर प्राप्त कर सकते हैं, फिर यदि आप एक परीक्षण करना चाहते हैं तो आप एक स्नैपशॉट बना सकते हैं और नए वॉल्यूम का उपयोग करके मशीन को पुनरारंभ कर सकते हैं।

LVM स्नैपशॉट को काम करने के लिए मूल वॉल्यूम की आवश्यकता होती है। ऐसा इसलिए है क्योंकि नया वॉल्यूम स्नैपशॉट और वास्तविक फाइल सिस्टम के बीच अंतर रखता है।

यदि आप सिस्टम को इस स्थिति में छोड़ देते हैं तो आप डिस्क स्पेस को बर्बाद करना शुरू कर देंगे क्योंकि नया फाइल सिस्टम बदल जाता है। मुझे नहीं पता कि क्या स्नैपशॉट और निश्चित फाइलशीट को मजबूत करने का कोई तरीका है। निश्चित रूप से आप एक और तार्किक मात्रा में dd कर सकते हैं, लेकिन इसके लिए आपको अपने फाइल सिस्टम के दो बार स्थान की आवश्यकता होगी और साथ ही आपके "रिकवरी के बिंदु" और वर्तमान स्थिति के बीच का अंतर भी होगा।

और यह सब रिबूट की आवश्यकता है और स्वचालित होने से बहुत दूर है।

यह भी माना जाता है कि कई आधुनिक फाइल सिस्टम इस तरह से चलते हैं, जैसे कि सोलारिस सिस्टम या प्रायोगिक btrfs पर zfs।


1

यह एक मेरे सिर पर थोड़ा सा है, लेकिन यह लगता है कि आप जो करना चाहते हैं वह बाइनरी फ़ाइलों (जैसे विभाजन छवि फ़ाइलों) का आंशिक बैकअप बनाना है। ऐसा करने के लिए डिज़ाइन किया गया एक पैकेज है (मैंने इसके बारे में सिर्फ पढ़ा है - इसे आज़माया नहीं है।)

एक नजर बूप पर।

https://github.com/apenwarr/bup

यह आपको कुछ विचार दे सकता है।

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.