que - ¿Eliminar los depósitos de Amazon S3?
s3 buckets regions (23)
Amazon recientemente agregó una nueva característica, "Eliminar varios objetos", que permite eliminar hasta 1000 objetos a la vez con una sola solicitud de API. Esto debería permitir la simplificación del proceso de eliminación de un gran número de archivos de un contenedor.
La documentación para la nueva característica está disponible aquí: http://docs.amazonwebservices.com/AmazonS3/latest/dev/DeletingMultipleObjects.html
He estado interactuando con Amazon S3 a través de S3Fox y parece que no puedo eliminar mis cubos. Selecciono un cubo, presiono eliminar, confirmo la eliminación en una ventana emergente, y ... no pasa nada. ¿Hay alguna otra herramienta que deba usar?
Arreglé un guión para hacerlo desde Python, eliminó con éxito mis 9000 objetos. Vea esta página:
Borre todos los objetos en el cubo primero. Luego puede eliminar el cubo en sí.
Aparentemente, uno no puede eliminar un cubo con objetos y S3Fox no hace esto por usted.
He tenido otros pequeños problemas con S3Fox yo mismo, así, y ahora uso una herramienta basada en Java, jets3t que es más próxima a las condiciones de error. Debe haber otros, también.
Con s3cmd: crea un nuevo directorio vacío s3cmd sync --delete-removed empty_directory s3: // yourbucket
Creo que la forma más fácil sería usar S3fm , un administrador de archivos gratuito en línea para Amazon S3. No hay aplicaciones para instalar, no hay registros de sitios web de terceros. Se ejecuta directamente desde Amazon S3, de forma segura y conveniente.
Simplemente selecciona tu cubo y presiona eliminar.
Es este un problema difícil. Mi solución está en http://stuff.mit.edu/~jik/software/delete-s3-bucket.pl.txt . Describe todas las cosas que he determinado que pueden salir mal en un comentario en la parte superior. Aquí está la versión actual del script (si lo cambio, pondré una nueva versión en la URL, pero probablemente no aquí).
#!/usr/bin/perl
# Copyright (c) 2010 Jonathan Kamens.
# Released under the GNU General Public License, Version 3.
# See <http://www.gnu.org/licenses/>.
# $Id: delete-s3-bucket.pl,v 1.3 2010/10/17 03:21:33 jik Exp $
# Deleting an Amazon S3 bucket is hard.
#
# * You can''t delete the bucket unless it is empty.
#
# * There is no API for telling Amazon to empty the bucket, so you have to
# delete all of the objects one by one yourself.
#
# * If you''ve recently added a lot of large objects to the bucket, then they
# may not all be visible yet on all S3 servers. This means that even after the
# server you''re talking to thinks all the objects are all deleted and lets you
# delete the bucket, additional objects can continue to propagate around the S3
# server network. If you then recreate the bucket with the same name, those
# additional objects will magically appear in it!
#
# It is not clear to me whether the bucket delete will eventually propagate to
# all of the S3 servers and cause all the objects in the bucket to go away, but
# I suspect it won''t. I also suspect that you may end up continuing to be
# charged for these phantom objects even though the bucket they''re in is no
# longer even visible in your S3 account.
#
# * If there''s a CR, LF, or CRLF in an object name, then it''s sent just that
# way in the XML that gets sent from the S3 server to the client when the
# client asks for a list of objects in the bucket. Unfortunately, the XML
# parser on the client will probably convert it to the local line ending
# character, and if it''s different from the character that''s actually in the
# object name, you then won''t be able to delete it. Ugh! This is a bug in the
# S3 protocol; it should be enclosing the object names in CDATA tags or
# something to protect them from being munged by the XML parser.
#
# Note that this bug even affects the AWS Web Console provided by Amazon!
#
# * If you''ve got a whole lot of objects and you serialize the delete process,
# it''ll take a long, long time to delete them all.
use threads;
use strict;
use warnings;
# Keys can have newlines in them, which screws up the communication
# between the parent and child processes, so use URL encoding to deal
# with that.
use CGI qw(escape unescape); # Easiest place to get this functionality.
use File::Basename;
use Getopt::Long;
use Net::Amazon::S3;
my $whoami = basename $0;
my $usage = "Usage: $whoami [--help] --access-key-id=id --secret-access-key=key
--bucket=name [--processes=#] [--wait=#] [--nodelete]
Specify --processes to indicate how many deletes to perform in
parallel. You''re limited by RAM (to hold the parallel threads) and
bandwidth for the S3 delete requests.
Specify --wait to indicate seconds to require the bucket to be verified
empty. This is necessary if you create a huge number of objects and then
try to delete the bucket before they''ve all propagated to all the S3
servers (I''ve seen a huge backlog of newly created objects take *hours* to
propagate everywhere). See the comment at the top of the script for more
information about this issue.
Specify --nodelete to empty the bucket without actually deleting it./n";
my($aws_access_key_id, $aws_secret_access_key, $bucket_name, $wait);
my $procs = 1;
my $delete = 1;
die if (! GetOptions(
"help" => sub { print $usage; exit; },
"access-key-id=s" => /$aws_access_key_id,
"secret-access-key=s" => /$aws_secret_access_key,
"bucket=s" => /$bucket_name,
"processess=i" => /$procs,
"wait=i" => /$wait,
"delete!" => /$delete,
));
die if (! ($aws_access_key_id && $aws_secret_access_key && $bucket_name));
my $increment = 0;
print "Incrementally deleting the contents of $bucket_name/n";
$| = 1;
my(@procs, $current);
for (1..$procs) {
my($read_from_parent, $write_to_child);
my($read_from_child, $write_to_parent);
pipe($read_from_parent, $write_to_child) or die;
pipe($read_from_child, $write_to_parent) or die;
threads->create(sub {
close($read_from_child);
close($write_to_child);
my $old_select = select $write_to_parent;
$| = 1;
select $old_select;
&child($read_from_parent, $write_to_parent);
}) or die;
close($read_from_parent);
close($write_to_parent);
my $old_select = select $write_to_child;
$| = 1;
select $old_select;
push(@procs, [$read_from_child, $write_to_child]);
}
my $s3 = Net::Amazon::S3->new({aws_access_key_id => $aws_access_key_id,
aws_secret_access_key => $aws_secret_access_key,
retry => 1,
});
my $bucket = $s3->bucket($bucket_name);
my $deleted = 1;
my $total_deleted = 0;
my $last_start = time;
my($start, $waited);
while ($deleted > 0) {
$start = time;
print "/nLoading ", ($increment ? "up to $increment" :
"as many as possible")," keys.../n";
my $response = $bucket->list({$increment ? (''max-keys'' => $increment) : ()})
or die $s3->err . ": " . $s3->errstr . "/n";
$deleted = scalar(@{ $response->{keys} }) ;
if (! $deleted) {
if ($wait and ! $waited) {
my $delta = $wait - ($start - $last_start);
if ($delta > 0) {
print "Waiting $delta second(s) to confirm bucket is empty/n";
sleep($delta);
$waited = 1;
$deleted = 1;
next;
}
else {
last;
}
}
else {
last;
}
}
else {
$waited = undef;
}
$total_deleted += $deleted;
print "/nDeleting $deleted keys($total_deleted total).../n";
$current = 0;
foreach my $key ( @{ $response->{keys} } ) {
my $key_name = $key->{key};
while (! &send(escape($key_name) . "/n")) {
print "Thread $current died/n";
die "No threads left/n" if (@procs == 1);
if ($current == @procs-1) {
pop @procs;
$current = 0;
}
else {
$procs[$current] = pop @procs;
}
}
$current = ($current + 1) % @procs;
threads->yield();
}
print "Sending sync message/n";
for ($current = 0; $current < @procs; $current++) {
if (! &send("/n")) {
print "Thread $current died sending sync/n";
if ($current = @procs-1) {
pop @procs;
last;
}
$procs[$current] = pop @procs;
$current--;
}
threads->yield();
}
print "Reading sync response/n";
for ($current = 0; $current < @procs; $current++) {
if (! &receive()) {
print "Thread $current died reading sync/n";
if ($current = @procs-1) {
pop @procs;
last;
}
$procs[$current] = pop @procs;
$current--;
}
threads->yield();
}
}
continue {
$last_start = $start;
}
if ($delete) {
print "Deleting bucket.../n";
$bucket->delete_bucket or die $s3->err . ": " . $s3->errstr;
print "Done./n";
}
sub send {
my($str) = @_;
my $fh = $procs[$current]->[1];
print($fh $str);
}
sub receive {
my $fh = $procs[$current]->[0];
scalar <$fh>;
}
sub child {
my($read, $write) = @_;
threads->detach();
my $s3 = Net::Amazon::S3->new({aws_access_key_id => $aws_access_key_id,
aws_secret_access_key => $aws_secret_access_key,
retry => 1,
});
my $bucket = $s3->bucket($bucket_name);
while (my $key = <$read>) {
if ($key eq "/n") {
print($write "/n") or die;
next;
}
chomp $key;
$key = unescape($key);
if ($key =~ /[/r/n]/) {
my(@parts) = split(//r/n|/r|/n/, $key, -1);
my(@guesses) = shift @parts;
foreach my $part (@parts) {
@guesses = (map(($_ . "/r/n" . $part,
$_ . "/r" . $part,
$_ . "/n" . $part), @guesses));
}
foreach my $guess (@guesses) {
if ($bucket->get_key($guess)) {
$key = $guess;
last;
}
}
}
$bucket->delete_key($key) or
die $s3->err . ": " . $s3->errstr . "/n";
print ".";
threads->yield();
}
return;
}
Esto es lo que uso Solo código ruby simple.
case bucket.size
when 0
puts "Nothing left to delete"
when 1..1000
bucket.objects.each do |item|
item.delete
puts "Deleting - #{bucket.size} left"
end
end
Esto puede ser un error en S3Fox, porque generalmente puede eliminar elementos recursivamente. Sin embargo, no estoy seguro si alguna vez traté de eliminar un cubo entero y su contenido a la vez.
El proyecto JetS3t , tal como lo menciona Stu, incluye un applet de GUI de Java que se puede ejecutar fácilmente en un navegador para administrar sus segmentos de S3: Cockpit . Tiene puntos fuertes y débiles en comparación con S3Fox, pero hay buenas posibilidades de que lo ayude a manejar su problemático cubo. Aunque requerirá que elimines los objetos primero, luego el cubo.
Descargo de responsabilidad: soy el autor de JetS3t y Cockpit
Finalmente es posible eliminar todos los archivos de una vez con la nueva función de reglas de ciclo de vida (caducidad). Incluso puede hacerlo desde la consola de AWS.
Simplemente haga clic derecho en el nombre del cubo en la consola de AWS, seleccione "Propiedades" y luego en la fila de pestañas en la parte inferior de la página seleccione "ciclo de vida" y "agregar regla". Cree una regla de ciclo de vida con el campo "Prefijo" establecido en blanco (en blanco significa todos los archivos en el depósito, o puede configurarlo en "a" para eliminar todos los archivos cuyos nombres comiencen con "a"). Establezca el campo "Días" a "1". Eso es. Hecho. Suponiendo que los archivos tienen más de un día, todos deberían eliminarse, luego puede eliminar el depósito.
Acabo de probar esto por primera vez, así que todavía estoy esperando ver qué tan rápido se eliminan los archivos (no fue instantáneo, pero presumiblemente debería ocurrir dentro de las 24 horas) y si me cobraron un comando de eliminación o 50 millones eliminaron comandos ... ¡dedos cruzados!
Implementé Bucket-destroy , una herramienta de múltiples hilos que hace todo lo posible para eliminar un cubo. Manejo los depósitos no vacíos, así como las claves de depósito habilitadas para la versión.
Puede leer la publicación del blog aquí http://bytecoded.blogspot.com/2011/01/recursive-delete-utility-for-version.html y las instrucciones aquí http://code.google.com/p/bucket-destroy/
He eliminado con éxito un cubo que contiene el doble ''//'' en el nombre de la clave, la tecla versionada y las teclas EliminarMarcador. Actualmente estoy ejecutando en un cubo que contiene ~ 40,000,000 hasta ahora he podido eliminar 1,200,000 en varias horas en m1.large. Tenga en cuenta que la utilidad es multiproceso pero no (todavía) implementada la reorganización (lo que hará una escala horizontal, iniciando la utilidad en varias máquinas).
Pruebe https://s3explorer.appspot.com/ para administrar su cuenta S3.
Recuerde que los bloques S3 deben estar vacíos antes de poder eliminarlos. La buena noticia es que la mayoría de las herramientas de terceros automatizan este proceso. Si tiene problemas con S3Fox, le recomiendo que pruebe S3FM para GUI o S3Sync para la línea de comandos. Amazon tiene un excelente artículo que describe cómo usar S3Sync . Después de configurar sus variables, el comando de teclado es
./s3cmd.rb deleteall <your bucket name>
La eliminación de depósitos con muchos archivos individuales tiende a bloquear muchas herramientas S3 porque intentan mostrar una lista de todos los archivos en el directorio. Debe encontrar una forma de eliminar en lotes. La mejor herramienta de GUI que he encontrado para este propósito es Bucket Explorer. Elimina archivos en un depósito S3 en 1000 fragmentos de archivos y no se bloquea al intentar abrir grandes depósitos como s3Fox y S3FM.
También encontré algunas secuencias de comandos que puedes usar para este propósito. No he probado estos guiones todavía, pero se ven bastante sencillos.
RUBÍ
require ''aws/s3''
AWS::S3::Base.establish_connection!(
:access_key_id => ''your access key'',
:secret_access_key => ''your secret key''
)
bucket = AWS::S3::Bucket.find(''the bucket name'')
while(!bucket.empty?)
begin
puts "Deleting objects in bucket"
bucket.objects.each do |object|
object.delete
puts "There are #{bucket.objects.size} objects left in the bucket"
end
puts "Done deleting objects"
rescue SocketError
puts "Had socket error"
end
end
PERL
#!/usr/bin/perl
use Net::Amazon::S3;
my $aws_access_key_id = ''your access key'';
my $aws_secret_access_key = ''your secret access key'';
my $increment = 50; # 50 at a time
my $bucket_name = ''bucket_name'';
my $s3 = Net::Amazon::S3->new({aws_access_key_id => $aws_access_key_id, aws_secret_access_key => $aws_secret_access_key, retry => 1, });
my $bucket = $s3->bucket($bucket_name);
print "Incrementally deleting the contents of $bucket_name/n";
my $deleted = 1;
my $total_deleted = 0;
while ($deleted > 0) {
print "Loading up to $increment keys.../n";
$response = $bucket->list({''max-keys'' => $increment, }) or die $s3->err . ": " . $s3->errstr . "/n";
$deleted = scalar(@{ $response->{keys} }) ;
$total_deleted += $deleted;
print "Deleting $deleted keys($total_deleted total).../n";
foreach my $key ( @{ $response->{keys} } ) {
my $key_name = $key->{key};
$bucket->delete_key($key->{key}) or die $s3->err . ": " . $s3->errstr . "/n";
}
}
print "Deleting bucket.../n";
$bucket->delete_bucket or die $s3->err . ": " . $s3->errstr;
print "Done./n";
FUENTE: Tarkblog
¡Espero que esto ayude!
Si tienes ruby (y rubygems ) instalados, instala aws-s3 gem con
gem install aws-s3
o
sudo gem install aws-s3
crea un archivo delete_bucket.rb :
require "rubygems" # optional
require "aws/s3"
AWS::S3::Base.establish_connection!(
:access_key_id => ''access_key_id'',
:secret_access_key => ''secret_access_key'')
AWS::S3::Bucket.delete("bucket_name", :force => true)
y ejecutarlo:
ruby delete_bucket.rb
Como Bucket#delete devolvió muchas excepciones de tiempo de espera, he ampliado el script:
require "rubygems" # optional
require "aws/s3"
AWS::S3::Base.establish_connection!(
:access_key_id => ''access_key_id'',
:secret_access_key => ''secret_access_key'')
while AWS::S3::Bucket.find("bucket_name")
begin
AWS::S3::Bucket.delete("bucket_name", :force => true)
rescue
end
end
Si usa la consola de Amazon y necesita una sola vez limpiar un cubo: puede buscar su cubo, luego seleccionar la tecla superior, luego desplazarse hacia abajo y luego presionar shift en el teclado y luego hacer clic en el de abajo. Seleccionará todo entre medio, luego puede hacer clic derecho y eliminar.
Siempre terminé usando su API C # y pequeños scripts para hacer esto. No estoy seguro de por qué S3Fox no puede hacerlo, pero esa funcionalidad parece estar rota en este momento. Estoy seguro de que muchas de las otras herramientas S3 pueden hacerlo también, sin embargo.
Soy uno de los miembros del Equipo de desarrolladores del equipo de Explorador de cubos. Proporcionaremos una opción diferente para eliminar cubos de acuerdo con la elección del usuario ... 1) Eliminación rápida: esta opción eliminará los datos del cubo en fragmentos de 1000. 2) Permanente Eliminar: esta opción eliminará los objetos en la cola.
Tendré que echar un vistazo a algunos de estos administradores de archivos alternativos. He usado (y me gusta) BucketExplorer, del que puedes obtener, sorprendentemente, http://www.bucketexplorer.com/ .
Es una prueba gratuita de 30 días, y luego (actualmente) cuesta $ 49.99 por licencia ($ 49.95 en la portada de la compra).
Un complemento más descarado: me cansé de esperar solicitudes de eliminación de HTTP individuales cuando tuve que eliminar 250,000 elementos, así que escribí un script de Ruby que lo hace multiproceso y lo completa en una fracción del tiempo:
http://github.com/sfeley/s3nuke/
Este es uno que funciona mucho más rápido en Ruby 1.9 debido a la forma en que se manejan los hilos.
Una técnica que se puede utilizar para evitar este problema es colocar todos los objetos en una "carpeta" en el depósito, lo que le permite eliminar la carpeta, seguir adelante y eliminar el depósito. Además, la herramienta s3cmd disponible en http://s3tools.org se puede utilizar para eliminar un depósito con archivos en él:
s3cmd rb --force s3://bucket-name
Utilice la consola de gestión web de Amazon. Con Google Chrome para la velocidad. Eliminó los objetos mucho más rápido que Firefox (aproximadamente 10 veces más rápido). Tenía 60 000 objetos para eliminar.
las versiones recientes de s3cmd tienen --recursive
p.ej,
~/$ s3cmd rb --recursive s3://bucketwithfiles
SpaceBlock también simplifica la eliminación de depósitos de s3: haga clic con el botón derecho del mouse en el cubo, elimínelo, aguarde a que se complete el trabajo en la vista de transferencias, listo.
Este es el front-end de windows s3 gratuito y de código abierto que mantengo, así que descarado, alerta de enchufe, etc.