Jak mogę wykonać kopię zapasową lub zsynchronizować wiadro Amazon S3?

Question

Mam ważne dane w wiadrze Amazon S3. Chcę tworzyć cotygodniowe kopie zapasowe innych treści do innej usługi w chmurze, a nawet do S3. Najlepszym sposobem byłoby zsynchronizowanie mojego wiadra z nowym pojemnikiem w innym regionie, w przypadku utraty danych.

Jak mogę to zrobić?

Answer 1

wolę do tworzenia kopii zapasowych lokalnie za pomocą synchronizacji gdzie tylko zmiany są aktualizowane. To nie jest idealnym rozwiązaniem do backupu ale można zaimplementować okresowe aktualizacje później, jak trzeba:

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

Jeśli nigdy nie używany s3cmd, zainstalować i skonfigurować go za pomocą:

pip install s3cmd 
s3cmd --configure 

Ponadto powinna istnieć kopia zapasowa S3 usługi za 5 USD/miesiąc, ale sprawdziłbym również Amazon Glacier, który pozwala umieścić prawie 40 GB pojedynczego pliku archiwum, jeśli korzystasz z wysyłania wieloczęściowego.

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

Pamiętaj, że jeśli Twoje konto S3 jest zagrożone, masz szansę na utratę wszystkich danych, jak można synchronizować pusty folder lub pliki zniekształcone. Więc lepiej napisz skrypt, aby zarchiwizować kopię zapasową kilka razy, np. Przez wykrycie początku tygodnia.

Aktualizacja 17.01.2016:

Python oparte AWS CLI jest już bardzo dojrzały.

Proszę używać: https://github.com/aws/aws-cli
Przykład: aws s3 sync s3://mybucket .

Answer 2

Ten skrypt kopiuje się wiadro 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() 

Używam tego w zadaniu natarcia (dla aplikacji Rails):

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

Próbowałem to zrobić w przeszłości, i to wciąż irytująco trudne, zwłaszcza z dużych, multi-GB, many-miliony-of-plików wiader . Najlepszym rozwiązaniem, jakie kiedykolwiek znalazłem, było S3S3Mirror, które zostało stworzone właśnie w tym celu.

To nie jest tak trywialne jak przerzucenie przełącznika, ale nadal jest lepsze niż w przypadku większości innych rozwiązań do majsterkowania, które wypróbowałem. Jest wielowątkowy i skopiuje pliki znacznie szybciej niż podobne podejścia z pojedynczym gwintem.

Jedna z propozycji: skonfiguruj ją na oddzielnej instancji EC2, a gdy ją uruchomisz, po prostu wyłącz ją, ale pozostaw tam AMI. Następnie, kiedy trzeba ponownie uruchomić, ponownie uruchomić maszynę i wszystko gotowe. To wcale nie jest tak ładne, jak prawdziwie zautomatyzowane rozwiązanie, ale można nim zarządzać co miesiąc lub co tydzień.

Answer 4

Najlepszym sposobem byłoby zsynchronizowanie mojego wiadra z nowym wiadrem w innym regionie w przypadku utraty danych.

Od 24 Mar 2015 jest to możliwe przy użyciu funkcji S3 w postaci Cross-Region Replication.

Jeden z wymienionych Use-case Scenarios jest „wymogi”, co wydaje się dopasować użytkową przypadek dodatkowej ochrony krytycznych danych przed utratą danych:

chociaż domyślnie, sklepy Amazon S3 dane w poprzek wiele geograficznie odległych stref dostępności, wymagania dotyczące zgodności mogą narzucać, że przechowujesz dane na jeszcze większych odległościach. Replikacja między regionami umożliwia replikowanie danych między odległymi regionami AWS w celu spełnienia wymagań zgodności.

Aby uzyskać instrukcje dotyczące konfiguracji, patrz How to Set Up Cross-Region Replication.