Wie kann ich einen Amazon S3-Bucket sichern oder synchronisieren?

Question

Ich habe kritische Daten in einem Amazon S3-Bucket. Ich möchte eine wöchentliche Sicherung seiner anderen Inhalte in einem anderen Cloud-Dienst oder sogar in S3 machen. Der beste Weg wäre, meinen Bucket im Falle eines Datenverlustes mit einem neuen Bucket in einer anderen Region zu synchronisieren.

Wie kann ich das tun?

Answer 1

Ich bevorzuge Backup lokal synchron mit dem nur Änderungen sind aktualisiert. Das ist nicht die perfekte Backup-Lösung, aber Sie können später regelmäßige Updates implementieren, wie Sie benötigen:

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

Wenn Sie noch nie s3cmd verwendet, installieren und konfigurieren Sie es mit:

pip install s3cmd 
s3cmd --configure 

Auch sollte es S3 Backup sein Dienste für $ 5/Monat, aber ich würde auch Amazon Glacier überprüfen, die Sie fast 40 GB einzelne Archivdatei legen können, wenn Sie mehrteiligen Upload verwenden.

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

Denken Sie daran, wenn Ihr S3 Konto kompromittiert ist, haben Sie die Chance, alle Ihre Daten zu verlieren, wie Sie einen leeren Ordner oder fehlerhafte Dateien synchronisieren würde. Schreiben Sie also besser ein Skript, um Ihre Sicherung einige Male zu archivieren, z. B. indem Sie den Beginn der Woche erkennen.

-Update 2016.01.17:

Python basierte AWS CLI ist jetzt sehr ausgereift.

Bitte verwenden: https://github.com/aws/aws-cli
Beispiel: aws s3 sync s3://mybucket .

Answer 2

Dieses Skript sichert einen S3-Kübel:

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

Ich benutze dies in einer Rake-Task (für eine Rails-Anwendung):

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

Ich habe versucht, dies in der Vergangenheit zu tun, und es ist immer noch annoyingly schwierig, vor allem bei großem, multi-GB, vielen Millionen-of-Dateien Eimer . Die beste Lösung, die ich je gefunden habe, war S3S3Mirror, die für genau diesen Zweck gemacht wurde.

Es ist nicht so trivial wie nur einen Schalter, aber es ist immer noch besser als die meisten anderen DIY-Lösungen, die ich ausprobiert habe. Es ist multi-threaded und kopiert die Dateien viel schneller als ähnliche single-threaded Ansätze.

Ein Vorschlag: Richten Sie es auf einer separaten EC2-Instanz ein, und wenn Sie es einmal ausgeführt haben, schalten Sie es aus, aber lassen Sie das AMI dort stehen. Dann, wenn Sie erneut laufen müssen, feuern Sie die Maschine wieder und Sie sind fertig. Dies ist bei weitem nicht so schön wie eine wirklich automatisierte Lösung, ist aber für monatliche oder wöchentliche Backups überschaubar.

Answer 4

Der beste Weg wäre die Möglichkeit, meinen Bucket im Falle eines Datenverlustes mit einem neuen Bucket in einer anderen Region zu synchronisieren.

Ab 24 Mar 2015 ist dies unter Verwendung der Cross-Region Replication-Funktion von S3 möglich.

Einer der aufgeführten Use-case Scenarios ist „Compliance-Anforderungen“, die Ihren Anwendungsfall von zusätzlichen Schutz kritischer Daten vor Datenverlust zu passen scheint:

Obwohl standardmäßig Amazon S3 speichert Ihre Daten über Bei mehreren geographisch entfernten Availability Zones können Compliance-Anforderungen die Speicherung von Daten in noch größeren Entfernungen vorschreiben. Mithilfe der bereichsübergreifenden Replikation können Sie Daten zwischen entfernten AWS-Regionen replizieren, um diese Compliance-Anforderungen zu erfüllen.

Anweisungen zur Einrichtung finden Sie unter How to Set Up Cross-Region Replication.