Amazon S3 버킷을 삭제 하시겠습니까?
S3Fox를 통해 Amazon S3와 상호 작용했는데 버킷을 삭제할 수없는 것 같습니다. 버킷을 선택하고 삭제를 누르고 팝업에서 삭제를 확인했는데 ... 아무 일도 일어나지 않습니다. 사용해야하는 다른 도구가 있습니까?
새로운 수명주기 (만료) 규칙 기능을 사용하여 한 번에 모든 파일을 삭제할 수 있습니다. AWS 콘솔에서도 수행 할 수 있습니다.
AWS 콘솔에서 버킷 이름을 마우스 오른쪽 버튼으로 클릭하고 "속성"을 선택한 다음 페이지 하단의 탭 행에서 "수명주기"및 "규칙 추가"를 선택하십시오. "접두사"필드를 비워두고 수명주기 규칙을 만듭니다 (비어 있으면 버킷의 모든 파일을 의미하거나 이름이 "a"로 시작하는 모든 파일을 삭제하려면 "a"로 설정할 수 있음). "일"필드를 "1"로 설정하십시오. 그게 다야. 끝난. 파일이 하루 이상 지난 경우 모두 삭제해야한다고 가정하면 버킷을 삭제할 수 있습니다.
나는 처음으로 이것을 시도했을 뿐이므로 파일이 얼마나 빨리 삭제되는지 (즉각적이지는 않았지만 아마도 24 시간 내에 발생해야 함) 그리고 내가 한 번의 삭제 명령 또는 5 천만 개의 삭제에 대해 청구되는지 여부를 기다리고 있습니다. 명령 ... 손가락이 엇갈 렸다!
S3 버킷을 삭제하려면 먼저 비어 있어야합니다. 좋은 소식은 대부분의 타사 도구가이 프로세스를 자동화한다는 것입니다. S3Fox에 문제가있는 경우 GUI 용 S3FM 또는 명령 줄용 S3Sync를 사용하는 것이 좋습니다. Amazon에는 S3Sync 사용 방법을 설명 하는 훌륭한 기사 가 있습니다 . 변수를 설정 한 후 주요 명령은
./s3cmd.rb deleteall <your bucket name>
개별 파일이 많은 버킷을 삭제하면 디렉토리의 모든 파일 목록을 표시하려고하기 때문에 많은 S3 도구가 충돌하는 경향이 있습니다. 일괄 삭제 방법을 찾아야합니다. 이 목적을 위해 찾은 최고의 GUI 도구는 Bucket Explorer입니다. 1000 개의 파일 청크에서 S3 버킷의 파일을 삭제하고 s3Fox 및 S3FM과 같은 대형 버킷을 열려고 할 때 충돌하지 않습니다.
이 목적으로 사용할 수있는 스크립트도 몇 가지 찾았습니다. 아직이 스크립트를 시도하지 않았지만 꽤 간단 해 보입니다.
루비
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
도움이 되었기를 바랍니다!
최신 버전의 s3cmd에는 --recursive가 있습니다.
예 :
~/$ s3cmd rb --recursive s3://bucketwithfiles
http://s3tools.org/kb/item5.htm
s3cmd 사용 : 새 빈 디렉터리 생성 s3cmd sync --delete-removed empty_directory s3 : // yourbucket
일반적으로 항목을 재귀 적으로 삭제할 수 있기 때문에 S3Fox의 버그 일 수 있습니다. 그러나 전체 버킷과 그 내용을 한 번에 삭제하려고 시도한 적이 있는지 확실하지 않습니다.
JetS3t의의 : 같은 스투 언급이 프로젝트는 자바 GUI가 쉽게 S3 버킷을 관리하는 브라우저에서 실행할 수있는 애플릿이 포함 조종석을 . S3Fox와 비교하여 강점과 약점을 모두 가지고 있지만 성가신 버킷을 처리하는 데 도움이 될 좋은 기회가 있습니다. 먼저 객체를 삭제 한 다음 버킷을 삭제해야합니다.
면책 조항 : 저는 JetS3t 및 Cockpit의 저자입니다.
SpaceBlock 을 사용하면 버킷을 마우스 오른쪽 버튼으로 클릭하고 삭제하고 전송보기에서 작업이 완료 될 때까지 기다립니다.
이것은 내가 유지하는 무료 오픈 소스 Windows s3 프런트 엔드이므로 뻔뻔한 플러그 경고 등입니다.
버킷 삭제에 필요한 모든 작업을 수행하는 다중 스레드 유틸리티 인 bucket-destroy를 구현 했습니다. 비어 있지 않은 버킷과 버전 지원 버킷 키를 처리합니다.
http://bytecoded.blogspot.com/2011/01/recursive-delete-utility-for-version.html 에서 블로그 게시물을 읽고 http://code.google.com/p/bucket- 에서 지침을 읽을 수 있습니다 . 멸하다/
키 이름, 버전이 지정된 키 및 DeleteMarker 키에 이중 '//'가 포함 된 버킷을 성공적으로 삭제했습니다. 현재까지 ~ 40,000,000이 포함 된 버킷에서 실행 중입니다. m1.large에서 몇 시간 동안 1,200,000을 삭제할 수있었습니다. 유틸리티는 다중 스레드이지만 (아직) 셔플 링 (수평 확장, 여러 컴퓨터에서 유틸리티 시작)을 구현하지 않습니다.
아마존 콘솔을 사용하고 일회성으로 버킷을 비워야하는 경우 : 버킷으로 이동 한 다음 상단 키를 선택한 다음 하단으로 스크롤 한 다음 키보드에서 Shift 키를 누른 다음 하단을 클릭합니다. 그 사이의 모든 것을 선택하면 마우스 오른쪽 버튼을 클릭하고 삭제할 수 있습니다.
당신이있는 경우 루비 (와 루비 젬 ) 설치를 설치, AWS-S3의 와 보석
gem install aws-s3
또는
sudo gem install aws-s3
파일 생성 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)
그것을 실행하십시오 :
ruby delete_bucket.rb
Bucket#delete시간 초과 예외가 많이 반환 된 이후 로 스크립트를 확장했습니다.
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
가장 쉬운 방법은 Amazon S3 용 무료 온라인 파일 관리자 인 S3fm 을 사용하는 것 입니다. 설치할 응용 프로그램이 없으며 타사 웹 사이트 등록이 없습니다. Amazon S3에서 직접 실행되며 안전하고 편리합니다.
버킷을 선택하고 삭제를 누르십시오.
이 문제를 방지하는 데 사용할 수있는 한 가지 기술은 모든 객체를 버킷의 "폴더"에 넣어 폴더를 삭제 한 다음 계속 진행하여 버킷을 삭제할 수 있도록하는 것입니다. 또한 http://s3tools.org 에서 제공되는 s3cmd 도구를 사용 하여 파일이있는 버킷을 삭제할 수 있습니다.
s3cmd rb --force s3://bucket-name
Python에서 스크립트를 함께 해킹하여 9000 개 객체를 성공적으로 제거했습니다. 이 페이지를보십시오 :
https://efod.se/blog/archive/2009/08/09/delete-s3-bucket
또 하나의 뻔뻔한 플러그 : 250,000 개의 항목을 삭제해야 할 때 개별 HTTP 삭제 요청을 기다리는 데 지쳐서 다중 스레드를 수행하고 짧은 시간 내에 완료하는 Ruby 스크립트를 작성했습니다.
http://github.com/sfeley/s3nuke/
이것은 스레드가 처리되는 방식 때문에 Ruby 1.9에서 훨씬 빠르게 작동합니다.
This is a hard problem. My solution is at http://stuff.mit.edu/~jik/software/delete-s3-bucket.pl.txt. It describes all of the things I've determined can go wrong in a comment at the top. Here's the current version of the script (if I change it, I'll put a new version at the URL but probably not here).
#!/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;
}
I am one of the Developer Team member of Bucket Explorer Team, We will provide different option to delete Bucket as per the users choice... 1) Quick Delete -This option will delete you data from bucket in chunks of 1000. 2) Permanent Delete-This option will Delete objects in queue.
How to delete Amazon S3 files and bucket?
Amazon recently added a new feature, "Multi-Object Delete", which allows up to 1,000 objects to be deleted at a time with a single API request. This should allow simplification of the process of deleting huge numbers of files from a bucket.
The documentation for the new feature is available here: http://docs.amazonwebservices.com/AmazonS3/latest/dev/DeletingMultipleObjects.html
I've always ended up using their C# API and little scripts to do this. I'm not sure why S3Fox can't do it, but that functionality appears to be broken within it at the moment. I'm sure that many of the other S3 tools can do it as well, though.
Delete all of the objects in the bucket first. Then you can delete the bucket itself.
Apparently, one cannot delete a bucket with objects in it and S3Fox does not do this for you.
I've had other little issues with S3Fox myself, like this, and now use a Java based tool, jets3t which is more forthcoming about error conditions. There must be others, too.
You must make sure you have correct write permission set for the bucket, and the bucket contains no objects. Some useful tools that can assist your deletion: CrossFTP, view and delete the buckets like the FTP client. jets3t Tool as mentioned above.
I'll have to have a look at some of these alternative file managers. I've used (and like) BucketExplorer, which you can get from - surprisingly - http://www.bucketexplorer.com/.
It's a 30 day free trial, then (currently) costing US$49.99 per licence (US$49.95 on the purchase cover page).
Try https://s3explorer.appspot.com/ to manage your S3 account.
This is what I use. Just simple ruby code.
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
Use the amazon web managment console. With Google chrome for speed. Deleted the objects a lot faster than firefox (about 10 times faster). Had 60 000 objects to delete.
ReferenceURL : https://stackoverflow.com/questions/27267/delete-amazon-s3-buckets
'IT TIP' 카테고리의 다른 글
| C에서 정수 길이 찾기 (0) | 2020.12.27 |
|---|---|
| addSubview 애니메이션 (0) | 2020.12.27 |
| 어떤 Linux 셸을 사용해야합니까? (0) | 2020.12.27 |
| Ubuntu에서 SmartGit 설치 및 사용 (0) | 2020.12.27 |
| Django CSRF 프레임 워크를 비활성화 할 수 없으며 내 사이트가 중단됩니다. (0) | 2020.12.27 |