मैं अमेज़ॅन एस 3 बाल्टी को बैकअप या सिंक कैसे कर सकता हूं?

Question

मेरे पास एक अमेज़ॅन एस 3 बाल्टी में महत्वपूर्ण डेटा है। मैं अपनी दूसरी सामग्री का साप्ताहिक बैकअप किसी अन्य क्लाउड सेवा, या यहां तक ​​कि S3 के अंदर भी बनाना चाहता हूं। डेटा हानि के मामले में, सबसे अच्छा तरीका मेरी बाल्टी को एक अलग क्षेत्र के अंदर एक नई बाल्टी में सिंक करना होगा।

मैं यह कैसे कर सकता हूं?

Answer 1

मैं स्थानीय रूप से सिंक जहां का उपयोग कर बैकअप के लिए पसंद करते हैं केवल परिवर्तन अद्यतन कर रहे हैं। यही कारण है कि सही बैकअप समाधान नहीं है, लेकिन आप आवधिक अद्यतन बाद में लागू कर सकते हैं के रूप में आप की जरूरत है:

s3cmd sync --delete-removed s3://your-bucket-name/ /path/to/myfolder/ 

आप s3cmd इस्तेमाल कभी नहीं किया है, तो स्थापित करें और का उपयोग कर इसे कॉन्फ़िगर करें:

pip install s3cmd 
s3cmd --configure 

इसके अलावा S3 बैकअप होना चाहिए $ 5/माह के लिए सेवाएं, लेकिन मैं अमेज़ॅन ग्लेशियर की भी जांच करूंगा जो आपको बहु-भाग अपलोड का उपयोग करने पर लगभग 40 जीबी एकल संग्रह फ़ाइल डाल देता है।

http://docs.aws.amazon.com/amazonglacier/latest/dev/uploading-archive-mpu.html#qfacts

याद रखें, यदि आपके S3 खाते के साथ छेड़छाड़ कर रहा है, तो आप अपने डेटा खो के रूप में आप कोई खाली फोल्डर या विकृत फ़ाइलों को समन्वयित होता मौका है। इसलिए, सप्ताह के आरंभ का पता लगाकर, आप अपने बैकअप को कुछ बार संग्रहीत करने के लिए बेहतर एक स्क्रिप्ट लिखते हैं।

अद्यतन 2016/01/17:

अजगर आधारित एडब्ल्यूएस CLI अब बहुत परिपक्व है।

का उपयोग करें: https://github.com/aws/aws-cli
उदाहरण: aws s3 sync s3://mybucket .

Answer 2

यह स्क्रिप्ट एक S3 बाल्टी बैकअप लेता है:

#!/usr/bin/env python 
from boto.s3.connection import S3Connection 
import re 
import datetime 
import sys 
import time 

def main(): 
    s3_ID = sys.argv[1] 
    s3_key = sys.argv[2] 
    src_bucket_name = sys.argv[3] 
    num_backup_buckets = sys.argv[4] 
    connection = S3Connection(s3_ID, s3_key) 
    delete_oldest_backup_buckets(connection, num_backup_buckets) 
    backup(connection, src_bucket_name) 

def delete_oldest_backup_buckets(connection, num_backup_buckets): 
    """Deletes the oldest backup buckets such that only the newest NUM_BACKUP_BUCKETS - 1 buckets remain.""" 
    buckets = connection.get_all_buckets() # returns a list of bucket objects 
    num_buckets = len(buckets) 

    backup_bucket_names = [] 
    for bucket in buckets: 
     if (re.search('backup-' + r'\d{4}-\d{2}-\d{2}' , bucket.name)): 
      backup_bucket_names.append(bucket.name) 

    backup_bucket_names.sort(key=lambda x: datetime.datetime.strptime(x[len('backup-'):17], '%Y-%m-%d').date()) 

    # The buckets are sorted latest to earliest, so we want to keep the last NUM_BACKUP_BUCKETS - 1 
    delete = len(backup_bucket_names) - (int(num_backup_buckets) - 1) 
    if delete <= 0: 
     return 

    for i in range(0, delete): 
     print 'Deleting the backup bucket, ' + backup_bucket_names[i] 
     connection.delete_bucket(backup_bucket_names[i]) 

def backup(connection, src_bucket_name): 
    now = datetime.datetime.now() 
    # the month and day must be zero-filled 
    new_backup_bucket_name = 'backup-' + str('%02d' % now.year) + '-' + str('%02d' % now.month) + '-' + str(now.day); 
    print "Creating new bucket " + new_backup_bucket_name 
    new_backup_bucket = connection.create_bucket(new_backup_bucket_name) 
    copy_bucket(src_bucket_name, new_backup_bucket_name, connection) 


def copy_bucket(src_bucket_name, dst_bucket_name, connection, maximum_keys = 100): 
    src_bucket = connection.get_bucket(src_bucket_name); 
    dst_bucket = connection.get_bucket(dst_bucket_name); 

    result_marker = '' 
    while True: 
     keys = src_bucket.get_all_keys(max_keys = maximum_keys, marker = result_marker) 

     for k in keys: 
      print 'Copying ' + k.key + ' from ' + src_bucket_name + ' to ' + dst_bucket_name 

      t0 = time.clock() 
      dst_bucket.copy_key(k.key, src_bucket_name, k.key) 
      print time.clock() - t0, ' seconds' 

     if len(keys) < maximum_keys: 
      print 'Done backing up.' 
      break 

     result_marker = keys[maximum_keys - 1].key 

if __name__ =='__main__':main() 

मैं (एक रेल अनुप्रयोग के लिए) एक रेक कार्य में इस का उपयोग करें:

desc "Back up a file onto S3" 
task :backup do 
    S3ID = "AKIAJM3FAKEFAKENRWVQ" 
    S3KEY = "0A5kuzV+F1pbaMjZxHQAZfakedeJd0dfakeNpry" 
    SRCBUCKET = "primary-mzgd" 
    NUM_BACKUP_BUCKETS = 2 

    Dir.chdir("#{Rails.root}/lib/tasks") 
    system "./do_backup.py #{S3ID} #{S3KEY} #{SRCBUCKET} #{NUM_BACKUP_BUCKETS}" 
end 

Answer 3

मैंने पहले भी यह करने के लिए कोशिश की है, और यह अभी भी annoyingly मुश्किल है, विशेष रूप से बड़े, बहु जीबी, कई-लाखों-ऑफ-द फ़ाइलों बाल्टी के साथ । मैंने पाया सबसे अच्छा समाधान S3S3Mirror था, जो वास्तव में इस उद्देश्य के लिए बनाया गया था।

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

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

Answer 4

डेटा हानि के मामले में एक अलग क्षेत्र में अपनी बाल्टी को एक नई बाल्टी के साथ सिंक करने की क्षमता होने का सबसे अच्छा तरीका होगा।

24 Mar 2015 के रूप में, यह Cross-Region Replication एस 3 की सुविधा का उपयोग कर संभव है।

हालांकि, अपने डेटा, अमेज़न S3 भंडार भर में डिफ़ॉल्ट रूप से:

सूचीबद्ध Use-case Scenarios में से एक है जो डेटा हानि के खिलाफ महत्वपूर्ण डेटा की अतिरिक्त सुरक्षा के आपके उपयोग-केस मिलान करने के लिए लगता है "अनुपालन आवश्यकताओं", है कई भौगोलिक दृष्टि से दूरस्थ उपलब्धता क्षेत्र, अनुपालन आवश्यकताएं यह निर्देश दे सकती हैं कि आप डेटा को और भी दूरी पर संग्रहीत करते हैं। क्रॉस-क्षेत्र प्रतिकृति आपको इन अनुपालन आवश्यकताओं को पूरा करने के लिए दूरस्थ एडब्ल्यूएस क्षेत्रों के बीच डेटा को दोहराने की अनुमति देती है।

सेटअप निर्देशों के लिए How to Set Up Cross-Region Replication देखें।