amazon s3 - reconoce - AWS S3 copia archivos y carpetas entre dos cubos
s3cmd (13)
He estado buscando una herramienta que me ayude a copiar el contenido de un segmento S3 en un segundo segmento sin descargar primero el contenido a un sistema local.
He intentado con la opción de copia de la consola AWS S3, pero eso ha provocado que falten algunos archivos anidados.
Intenté usar la aplicación Transmitir (Pánico) pero el comando duplicado primero copia los archivos al sistema local y luego al segundo segmento.
Copiar entre cubos en diferentes regiones
$ aws s3 cp s3://src_bucket/file s3://dst_bucket/file --source-region eu-west-1 --region ap-northeast-1
El comando anterior copia un archivo de un cubo en Europa (eu-west-1) a Japón (ap-northeast-1). Puede obtener el nombre del código para la región de su contenedor con este comando:
$ aws s3api get-bucket-location --bucket my_bucket
Por cierto, usar Copiar y Pegar en la consola web de S3 es fácil, pero parece que se descarga desde el depósito de origen en el navegador y luego se carga en el depósito de destino. Usar "aws s3" fue mucho más rápido para mí.
Copiar entre Cubos S3
AWS (hace poco) lanzó una interfaz de línea de comandos para copiar entre sectores.
$ aws s3 sync s3://mybucket-src s3://mybucket-target --exclude *.tmp
..
Esto copiará de un cubo objetivo a otro cubo.
Consulte la documentación aquí: Documentación S3 CLI
Ahora puede hacerlo desde la interfaz de administración S3. Solo ingrese en un cubo seleccione todas las actions->copy carpetas- actions->copy . Luego muévete a tus nuevas actions->paste .
Consulte la documentación a continuación. Supongo que eso es lo que estás buscando. http://docs.amazonwebservices.com/AmazonS3/latest/API/RESTObjectCOPY.html
RightAws gem''s S3Interface tiene una función de copia que hace lo anterior.
http://rubydoc.info/gems/right_aws/3.0.0/RightAws/S3Interface#copy-instance_method
Es posible con la reciente gema aws-sdk , vea el ejemplo del código:
require ''aws-sdk''
AWS.config(
:access_key_id => ''***'',
:secret_access_key => ''***'',
:max_retries => 10
)
file = ''test_file.rb''
bucket_0 = {:name => ''bucket_from'', :endpoint => ''s3-eu-west-1.amazonaws.com''}
bucket_1 = {:name => ''bucket_to'', :endpoint => ''s3.amazonaws.com''}
s3_interface_from = AWS::S3.new(:s3_endpoint => bucket_0[:endpoint])
bucket_from = s3_interface_from.buckets[bucket_0[:name]]
bucket_from.objects[file].write(open(file))
s3_interface_to = AWS::S3.new(:s3_endpoint => bucket_1[:endpoint])
bucket_to = s3_interface_to.buckets[bucket_1[:name]]
bucket_to.objects[file].copy_from(file, {:bucket => bucket_from})
más detalles: cómo copiar el archivo en los cubos utilizando la gema aws-s3
Escribí un script que respalda un cubo de S3: https://github.com/roseperrone/aws-backup-rake-task
#!/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()
Lo uso en una tarea de rake (para una aplicación de Rails):
desc "Back up a file onto S3"
task :backup do
S3ID = "AKIAJM3NRWC7STXWUWVQ"
S3KEY = "0A5kuzV+E1dkaPjZxHQAezz1GlSddJd0iS5sNpry"
SRCBUCKET = "primary-mzgd"
NUM_BACKUP_BUCKETS = 2
Dir.chdir("#{Rails.root}/lib/tasks")
system "./do_backup.py #{S3ID} #{S3KEY} #{SRCBUCKET} #{NUM_BACKUP_BUCKETS}"
end
Escuché que hay un módulo de nodo para eso si te gusta JavaScript: p
De los documentos knox-copy :
knoxCopy = require ''knox-copy''
client = knoxCopy.createClient
key: ''<api-key-here>''
secret: ''<secret-here>''
bucket: ''backups''
client.copyBucket
fromBucket: ''uploads''
fromPrefix: ''/nom-nom''
toPrefix: "/upload_backups/#{new Date().toISOString()}"
(err, count) ->
console.log "Copied #{count} files"
Me imagino que probablemente ya hayas encontrado una buena solución, pero para otras personas que se enfrentan con este problema (como lo estuve hace poco), he creado una utilidad simple específicamente para el reflejo de un cubo S3 en otro en una manera muy concurrente, pero con CPU y eficiente de memoria.
Está en github bajo una licencia de Apache aquí: https://github.com/cobbzilla/s3s3mirror
Cuando tienes un cubo muy grande y buscas el máximo rendimiento, puede valer la pena intentarlo.
Si decides intentarlo, avísame si tienes algún comentario.
Me informaron que también puedes hacer esto usando s3distcp en un clúster de EMR. Se supone que es más rápido para los datos que contienen archivos grandes. Funciona bastante bien en pequeños conjuntos de datos, pero hubiera preferido otra solución dada la curva de aprendizaje que se necesitó para configurar tan pocos datos (nunca antes había trabajado con EMR).
Aquí hay un enlace de la documentación de AWS: http://docs.aws.amazon.com/ElasticMapReduce/latest/DeveloperGuide/UsingEMR_s3distcp.html
Actualización: para el mismo conjunto de datos, s3s3mirror fue mucho más rápido que s3distcp o AWS cli. Mucho más fácil de configurar, también.
Para copiar de un cubo S3 al mismo u otro cubo S3 sin descargar a local, es bastante simple. Use el siguiente comando de shell.
hdfs dfs -cp -f "s3://AccessKey:SecurityKey@ExternalBucket/SourceFoldername/*.*" "s3://AccessKey:SecurityKey@ExternalBucket/TargetFoldername"
Esto copiará todos los archivos de la carpeta SourceFoldername del TargetFoldername de TargetFoldername carpeta TargetFoldername del TargetFoldername de TargetFoldername . En el código anterior, reemplace AccessKey , SecurityKey y ExternalBucket con sus valores correspondientes.
Si está en shell y desea copiar varios archivos, pero no todos: s3cmd cp --recursive s3: // BUCKET1 / OBJECT1 s3: // BUCKET2 [/ OBJECT2]
Un ejemplo simplificado usando la gema aws-sdk:
AWS.config(:access_key_id => ''...'', :secret_access_key => ''...'')
s3 = AWS::S3.new
s3.buckets[''bucket-name''].objects[''source-key''].copy_to(''target-key'')
Si desea realizar la copia entre diferentes cubos, especifique el nombre del depósito de destino:
s3.buckets[''bucket-name''].objects[''source-key''].copy_to(''target-key'', :bucket_name => ''target-bucket'')
Creé un ejecutable Docker de la herramienta s3s3mirror . Una utilidad para copiar y duplicar desde un contenedor AWS S3 a otro.
Está enhebrado, lo que permite una COPIA paralela y una gran eficiencia de memoria. Tiene éxito cuando s3cmd falla por completo.
Uso:
docker run -e AWS_ACCESS_KEY_ID=FOO -e AWS_SECRET_ACCESS_KEY=BAR pmoust/s3s3mirror [OPTIONS] source_bucket[/prefix] dest_bucket[/prefix]
Para obtener una lista completa de opciones, pruebe:
docker run pmoust/s3s3mirror