कैसे एक S3 बाल्टी से पुनरावर्ती फ़ाइलों को हटाने के लिए

Question 1

मेरे पास S3 में निम्न फ़ोल्डर संरचना है। वहाँ एक निश्चित फ़ोल्डर के तहत सभी फ़ाइलों को पुन: हटाने के लिए एक तरीका है (कहते हैं foo/bar1 or foo or foo/bar2/1..)

foo/bar1/1/..
foo/bar1/2/..
foo/bar1/3/..

foo/bar2/1/..
foo/bar2/2/..
foo/bar2/3/..

Question 2

नवीनतम aws-cli python कमांड लाइन टूल्स के साथ , एक बाल्टी में एक फ़ोल्डर के तहत सभी फ़ाइलों को पुन: प्राप्त करने के लिए बस:

aws s3 rm --recursive s3://your_bucket_name/foo/

या बाल्टी के नीचे सब कुछ हटा दें:

aws s3 rm --recursive s3://your_bucket_name

यदि आप चाहते हैं कि वास्तव में बाल्टी को हटाना है, तो एक-चरण शॉर्टकट है:

aws s3 rb --force s3://your_bucket_name

जो फिर से बाल्टी में उस सामग्री को हटा देगा फिर बाल्टी को हटा दें।

नोट: s3://इन कमांड को काम करने के लिए प्रोटोकॉल उपसर्ग की आवश्यकता होती है

Question 3

इसके लिए प्रति कुंजी (फाइल) एक समर्पित एपीआई कॉल की आवश्यकता थी, लेकिन दिसंबर 2011 में अमेज़न एस 3 - मल्टी-ऑब्जेक्ट डिलीट की शुरुआत के कारण इसे बहुत सरल बना दिया गया है :

अमेज़ॅन S3 की नई मल्टी-ऑब्जेक्ट डिलीट आपको S3 बाल्टी से 1000 वस्तुओं को एक ही अनुरोध के साथ हटाने की क्षमता देती है।

इस पर और अधिक और इसके लिए PHP में संबंधित उदाहरण (PHP के लिए एडब्ल्यूएस एसडीके संस्करण 1.4.8 से समर्थन करता है ) के लिए वाइल्डकार्ड का उपयोग करते हुए एस 3 से संबंधित प्रश्न हटाएं से मेरा उत्तर देखें ।

अधिकांश AWS ग्राहक पुस्तकालयों ने इस तरह एक या दूसरे तरीके से इस कार्यक्षमता के लिए समर्पित समर्थन पेश किया है, जैसे:

अजगर

आप इसे उत्कृष्ट बोटो पाइथन इंटरफेस के साथ AWS के साथ लगभग इस प्रकार प्राप्त कर सकते हैं (अप्रयुक्त, मेरे सिर के ऊपर से):

import boto
s3 = boto.connect_s3()
bucket = s3.get_bucket("bucketname")
bucketListResultSet = bucket.list(prefix="foo/bar")
result = bucket.delete_keys([key.name for key in bucketListResultSet])

माणिक

यह रूबी के लिए एडब्ल्यूएस एसडीके के संस्करण 1.24 के बाद से उपलब्ध है और रिलीज नोट्स एक उदाहरण भी प्रदान करते हैं:

bucket = AWS::S3.new.buckets['mybucket']

# delete a list of objects by keys, objects are deleted in batches of 1k per
# request.  Accepts strings, AWS::S3::S3Object, AWS::S3::ObectVersion and 
# hashes with :key and :version_id
bucket.objects.delete('key1', 'key2', 'key3', ...)

# delete all of the objects in a bucket (optionally with a common prefix as shown)
bucket.objects.with_prefix('2009/').delete_all

# conditional delete, loads and deletes objects in batches of 1k, only
# deleting those that return true from the block
bucket.objects.delete_if{|object| object.key =~ /\.pdf$/ }

# empty the bucket and then delete the bucket, objects are deleted in batches of 1k
bucket.delete!

या:

AWS::S3::Bucket.delete('your_bucket', :force => true)

Question 4

आप उपसर्ग के साथ फ़ाइलों के लिए एक समाप्ति बनाने के लिए अमेज़ॅन एस 3 लाइफसाइकल का उपयोग करने पर भी विचार कर सकते हैं foo/bar1।

S3 ब्राउज़र कंसोल खोलें और एक बाल्टी पर क्लिक करें। उसके बाद Properties और फिर LifeCycle पर क्लिक करें।

उपसर्ग के साथ सभी फ़ाइलों के लिए एक समाप्ति नियम बनाएँ foo/bar1 और फ़ाइल बनाने के बाद से तारीख को 1 दिन निर्धारित करें।

सहेजें और सभी मिलान फ़ाइलें 24 घंटों के भीतर चली जाएंगी।

आपके द्वारा किए जाने के बाद नियम को हटाना न भूलें!

कोई API कॉल, कोई तृतीय पक्ष लाइब्रेरी, एप्लिकेशन या स्क्रिप्ट नहीं।

मैंने अभी कई मिलियन फाइलें इस तरह से डिलीट की हैं।

एक स्क्रीनशॉट जो जीवनचक्र नियम खिड़की दिखा रहा है (इस शॉट में प्रीफिक्स को खाली छोड़ दिया गया है, बाल्टी में सभी कुंजियों को प्रभावित करता है):

यहाँ छवि विवरण दर्ज करें

Question 5

यदि आप जावा एडब्ल्यूएस एसडीके 2.0 का उपयोग करके "फू /" उपसर्ग के साथ सभी वस्तुओं को निकालना चाहते हैं

import java.util.ArrayList;
import java.util.Iterator;
import software.amazon.awssdk.services.s3.S3Client;
import software.amazon.awssdk.services.s3.model.*;

//...

ListObjectsRequest listObjectsRequest = ListObjectsRequest.builder()
    .bucket(bucketName)
    .prefix("foo/")
    .build()
;
ListObjectsResponse objectsResponse = s3Client.listObjects(listObjectsRequest);

while (true) {
    ArrayList<ObjectIdentifier> objects = new ArrayList<>();

    for (Iterator<?> iterator = objectsResponse.contents().iterator(); iterator.hasNext(); ) {
        S3Object s3Object = (S3Object)iterator.next();
        objects.add(
            ObjectIdentifier.builder()
                .key(s3Object.key())
                .build()
        );
    }

    s3Client.deleteObjects(
        DeleteObjectsRequest.builder()
            .bucket(bucketName)
            .delete(
                Delete.builder()
                    .objects(objects)
                    .build()
            )
            .build()
    );

    if (objectsResponse.isTruncated()) {
        objectsResponse = s3Client.listObjects(listObjectsRequest);
        continue;
    }

    break;
};

Question 6

s3cmdलिनक्स मशीन पर स्थापित पैकेज के साथ , आप ऐसा कर सकते हैं

s3cmd rm s3://foo/bar --recursive

Question 7

माणिक V2 के लिए AWS-SKD का उपयोग करने के मामले में।

s3.list_objects(bucket: bucket_name, prefix: "foo/").contents.each do |obj|
  next if obj.key == "foo/" 
  resp = s3.delete_object({
    bucket: bucket_name,
    key: obj.key,
  })
end

कृपया ध्यान दें, बाल्टी के नीचे सभी "फू / *" हट जाएंगे।

Question 8

मैंने अभी PowerShell का उपयोग करके अपनी बाल्टी से सभी फाइलें हटा दी हैं:

Get-S3Object -BucketName YOUR_BUCKET | % { Remove-S3Object -BucketName YOUR_BUCKET -Key $_.Key -Force:$true }

Question 9

बस देखा कि अमेज़ॅन ने एडब्ल्यूएस कंसोल मेनू में "हाउ टू खाली ए बकेट" विकल्प जोड़ा:

http://docs.aws.amazon.com/AmazonS3/latest/UG/DeletingaBucket.html

Question 10

मतदान का जवाब एक कदम याद आ रहा है।

प्रति a3 s सहायता

वर्तमान में, कमांड के पथ तर्क में UNIX शैली वाइल्डकार्ड के उपयोग के लिए कोई समर्थन नहीं है। हालाँकि, अधिकांश कमांड्स --exclude "<value>"और --include "<value>" पैरामीटर हैं जो वांछित परिणाम प्राप्त कर सकते हैं ......... जब कई फिल्टर होते हैं, तो नियम फ़िल्टर होते हैं जो बाद में कमांड में दिखाई देते हैं जो पहले कमांड में दिखाई देने वाले फिल्टर पर पूर्वता लेते हैं। उदाहरण के लिए, यदि फ़िल्टर पैरामीटर कमांड को पास किया गया था। --exclude "*" --include "*.txt"सभी फाइलें .txt के साथ समाप्त होने वाली फाइलों को छोड़कर सभी फाइलों को कमांड से बाहर कर दिया जाएगा

aws s3 rm --recursive s3://bucket/ --exclude="*" --include="/folder_path/*"

Question 11

सबसे अच्छा तरीका है कि पूरी बाल्टी सामग्री को हटाने के लिए जीवनचक्र नियम का उपयोग किया जाए। प्रोग्रामिक रूप से आप निम्न कोड (PHP) का उपयोग जीवनचक्र नियम को करने के लिए कर सकते हैं।

$expiration = array('Date' => date('U', strtotime('GMT midnight')));
$result = $s3->putBucketLifecycle(array(
            'Bucket' => 'bucket-name',
            'Rules' => array(
                array(
                    'Expiration' => $expiration,
                    'ID' => 'rule-name',
                    'Prefix' => '',
                    'Status' => 'Enabled',
                ),
            ),
        ));

उपरोक्त मामले में सभी वस्तुओं को शुरू होने की तारीख से हटा दिया जाएगा - "आज जीएमटी आधी रात"।

आप दिन को निम्नानुसार भी निर्दिष्ट कर सकते हैं। लेकिन डेज़ के साथ यह बाल्टी की सामग्री को हटाने के लिए कम से कम 24 घंटे (1 दिन न्यूनतम है) की प्रतीक्षा करेगा।

$expiration = array('Days' => 1);

Question 12

मुझे निम्नलिखित करने की आवश्यकता है ...

def delete_bucket
  s3 = init_amazon_s3
  s3.buckets['BUCKET-NAME'].objects.each do |obj|
    obj.delete
  end
end

def init_amazon_s3
  config = YAML.load_file("#{Rails.root}/config/s3.yml")
  AWS.config(:access_key_id => config['access_key_id'],:secret_access_key => config['secret_access_key'])
  s3 = AWS::S3.new
end