amazon s3 - अमेज़ॅन एस 3 बाल्टी हटाएं?




amazon-s3 buckets (16)

S3cmd के साथ: एक नई खाली निर्देशिका बनाएँ s3cmd सिंक - हटाया गया हटाया गया खाली_डायरेक्टरी s3: // yourbucket

मैं एस 3 S3Fox माध्यम से अमेज़ॅन एस 3 के साथ बातचीत कर रहा S3Fox और मैं अपनी बाल्टी को हटाने के लिए प्रतीत नहीं कर सकता। मैं एक बाल्टी का चयन करता हूं, हटाएं हिट करता हूं, पॉपअप में डिलीट की पुष्टि करता हूं, और ... कुछ भी नहीं होता है। क्या कोई और उपकरण है जिसका मुझे उपयोग करना चाहिए?


s3cmd के हाल के संस्करणों में --recursive है

जैसे,

~/$ s3cmd rb --recursive s3://bucketwithfiles

http://s3tools.org/kb/item5.htm


अमेज़ॅन ने हाल ही में एक नई सुविधा, "मल्टी-ऑब्जेक्ट डिलीट" जोड़ा है, जो एक ही एपीआई अनुरोध के साथ एक समय में 1,000 ऑब्जेक्ट्स को हटाने की अनुमति देता है। यह एक बाल्टी से बड़ी संख्या में फाइलों को हटाने की प्रक्रिया के सरलीकरण की अनुमति देनी चाहिए।

नई सुविधा के लिए प्रलेखन यहां उपलब्ध है: http://docs.amazonwebservices.com/AmazonS3/latest/dev/DeletingMultipleObjects.html


अमेज़ॅन वेब मैनेजमेंट कंसोल का प्रयोग करें। गति के लिए Google क्रोम के साथ। ऑब्जेक्ट को फ़ायरफ़ॉक्स से लगभग तेज़ हटा दिया गया (लगभग 10 गुना तेज)। हटाने के लिए 60 000 वस्तुओं था।


इस तकनीक से बचने के लिए इस्तेमाल की जा सकने वाली एक तकनीक बाल्टी में "ऑब्जेक्ट" में सभी ऑब्जेक्ट्स डाल रही है, जिससे आप फ़ोल्डर को हटा सकते हैं और बाल्टी को हटा सकते हैं। इसके अतिरिक्त, http://s3tools.org से उपलब्ध s3cmd टूल का उपयोग फ़ाइलों में एक बाल्टी को हटाने के लिए किया जा सकता है:

s3cmd rb --force s3://bucket-name

एक और लापरवाही प्लग: जब मैं 250,000 आइटमों को हटाना पड़ा, तो मैं अलग-अलग HTTP डिलीट अनुरोधों की प्रतीक्षा करने से थक गया, इसलिए मैंने रूबी लिपि लिखी जो कि उस समय के अंश में बहुप्रचारित और पूर्ण हो जाती है:

http://github.com/sfeley/s3nuke/

यह वह है जो रूबी 1.9 में बहुत तेजी से काम करता है क्योंकि धागे को संभाला जाता है।


पहले बाल्टी में सभी वस्तुओं को हटा दें। फिर आप बाल्टी को हटा सकते हैं।

जाहिर है, कोई वस्तु में वस्तुओं के साथ एक बाल्टी नहीं हटा सकता है और S3Fox यह आपके लिए नहीं करता है।

मेरे पास S3Fox के साथ अन्य छोटे मुद्दे हैं, इस तरह, और अब जावा आधारित टूल का उपयोग करें, jets3t जो त्रुटि स्थितियों के बारे में अधिक आ रहा है। दूसरों को भी होना चाहिए।


मुझे इन वैकल्पिक फ़ाइल प्रबंधकों में से कुछ को देखना होगा। मैंने (और पसंद) BucketExplorer का उपयोग किया है, जिसे आप प्राप्त कर सकते हैं - आश्चर्यजनक रूप से - http://www.bucketexplorer.com/

यह 30 दिन का नि: शुल्क परीक्षण है, फिर (वर्तमान में) प्रति लाइसेंस यूएस $ 49.99 (खरीद कवर पेज पर यूएस $ 49.95) की लागत है।


मैं बाल्टी एक्सप्लोरर टीम के डेवलपर टीम सदस्य में से एक हूं, हम उपयोगकर्ताओं की पसंद के अनुसार बाल्टी को हटाने के लिए अलग-अलग विकल्प प्रदान करेंगे ... 1) त्वरित हटाएं- यह विकल्प आपको 1000 के हिस्सों में बाल्टी से डेटा हटा देगा। 2) स्थायी हटाएं- यह विकल्प कतार में ऑब्जेक्ट हटा देगा।

अमेज़ॅन एस 3 फाइलों और बाल्टी को कैसे हटाएं?


मैं हमेशा ऐसा करने के लिए अपने सी # एपीआई और छोटी लिपियों का उपयोग कर समाप्त हो गया है। मुझे यकीन नहीं है कि S3Fox ऐसा क्यों नहीं कर सकता है, लेकिन इस कार्यक्षमता को इस समय में तोड़ा जा सकता है। मुझे यकीन है कि अन्य एस 3 उपकरण भी कई ऐसा कर सकते हैं।


मैंने पाइथन से इसे करने के लिए एक स्क्रिप्ट को एक साथ हैक किया, यह सफलतापूर्वक मेरी 9 000 वस्तुओं को हटा दिया। इस पन्ने को देखें:

https://efod.se/blog/archive/2009/08/09/delete-s3-bucket


यदि आप अमेज़ॅन के कंसोल का उपयोग करते हैं और एक बार आधार पर बाल्टी को साफ़ करने की आवश्यकता होती है: आप अपनी बाल्टी पर ब्राउज़ कर सकते हैं तो शीर्ष कुंजी का चयन करें और फिर नीचे स्क्रॉल करें और फिर अपने कीबोर्ड पर Shift दबाएं और फिर नीचे एक पर क्लिक करें। यह बीच में सभी का चयन करेगा, फिर आप दायाँ क्लिक और हटा सकते हैं।


यह S3Fox में एक बग हो सकता है, क्योंकि यह आमतौर पर आइटम को रिकर्सली से हटाने में सक्षम होता है। हालांकि, मुझे यकीन नहीं है कि मैंने कभी एक पूरी बाल्टी और इसकी सामग्री को एक बार हटाने की कोशिश की है।

JetS3t प्रोजेक्ट, जैसा कि स्टू द्वारा उल्लिखित है, में एक जावा जीयूआई एप्लेट शामिल है जिसे आप अपने एस 3 बाल्टी प्रबंधित करने के लिए आसानी से ब्राउज़र में चला सकते हैं: Cockpit । इसमें एस 3 फॉक्स की तुलना में ताकत और कमजोरियां हैं, लेकिन यह एक अच्छा मौका है कि इससे आपको परेशानी बाल्टी से निपटने में मदद मिलेगी। यद्यपि इसे पहले ऑब्जेक्ट्स को हटाने की आवश्यकता होगी, फिर बाल्टी।

अस्वीकरण: मैं JetS3t और कॉकपिट के लेखक हूं


यह एक कठिन समस्या है। मेरा समाधान http://stuff.mit.edu/~jik/software/delete-s3-bucket.pl.txt । यह बताता है कि मैंने जो कुछ भी निर्धारित किया है, वह शीर्ष पर एक टिप्पणी में गलत हो सकता है। यहां स्क्रिप्ट का वर्तमान संस्करण है (यदि मैं इसे बदलता हूं, तो मैं यूआरएल पर एक नया संस्करण डालूंगा लेकिन शायद यहां नहीं)।

#!/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;
}

याद रखें कि एस 3 बाल्टी को हटाए जाने से पहले खाली होना चाहिए। अच्छी खबर यह है कि अधिकांश तृतीय पक्ष औजार इस प्रक्रिया को स्वचालित करते हैं। यदि आप S3Fox के साथ समस्याएं चला रहे हैं, तो मैं कमांड लाइन के लिए GUI या S3Sync के लिए S3FM को आजमाने की सलाह देता हूं। अमेज़ॅन का एक महान लेख है जिसमें एस 3 सिंक का उपयोग करने का वर्णन किया गया है । अपने चर सेट अप करने के बाद, कुंजी कमांड है

./s3cmd.rb deleteall <your bucket name>

कई अलग-अलग फाइलों के साथ बाल्टी हटाने से बहुत सारे एस 3 टूल्स दुर्घटनाग्रस्त हो जाते हैं क्योंकि वे निर्देशिका में सभी फाइलों की एक सूची प्रदर्शित करने का प्रयास करते हैं। आपको बैचों में हटाने का तरीका ढूंढना होगा। इस उद्देश्य के लिए मैंने पाया है कि सबसे अच्छा जीयूआई उपकरण बाल्टी एक्सप्लोरर है। यह 1000 फ़ाइल भागों में एस 3 बाल्टी में फ़ाइलों को हटा देता है और एस 3 फॉक्स और एस 3 एफएम जैसी बड़ी बाल्टी खोलने की कोशिश करते समय क्रैश नहीं होता है।

मुझे कुछ स्क्रिप्ट भी मिली हैं जिनका उपयोग आप इस उद्देश्य के लिए कर सकते हैं। मैंने अभी तक इन स्क्रिप्ट को आजमाया नहीं है लेकिन वे बहुत सरल दिखते हैं।

माणिक

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";

स्रोत: Tarkblog

उम्मीद है की यह मदद करेगा!


SpaceBlock एस 3 बाल्टी को हटाने में भी आसान बनाता है - बाल्टी क्लिक करें, हटाएं, स्थानान्तरण दृश्य में पूरा करने के लिए नौकरी की प्रतीक्षा करें, किया गया।

यह मुफ़्त और ओपन सोर्स विंडोज़ एस 3 फ्रंट एंड है जो मैं बनाए रखता हूं, इतनी लापरवाह प्लग अलर्ट इत्यादि।







buckets