बोटो 3 के साथ एक बाल्टी की सामग्री की सूची बनाना

Question

मैं कैसे देख सकता हूं कि S3 में बाल्टी के अंदर क्या है boto3? (यानी करते हैं "ls")?

निम्न कार्य करना:

import boto3
s3 = boto3.resource('s3')
my_bucket = s3.Bucket('some/path/')

रिटर्न:

s3.Bucket(name='some/path/')

मुझे इसकी सामग्री कैसे दिखती है?

Answer 1

सामग्री देखने का एक तरीका यह होगा:

for my_bucket_object in my_bucket.objects.all():
    print(my_bucket_object)

Comments

क्या मैं बाल्टी में विशेष पथ के तहत या विशेष सीमांकक के साथ boto3 का उपयोग कर सकता हूँ ??

— राहुल केपी

आपको कहने में सक्षम होना चाहिए mybucket.objects.filter(Prefix='foo/bar')और यह केवल उस उपसर्ग के साथ वस्तुओं को सूचीबद्ध करेगा। आप एक Delimiterपैरामीटर भी पास कर सकते हैं ।

— गरनाट

Boto3 के साथ काम नहीं कर रहा है। गुण: 'S3' ऑब्जेक्ट में कोई विशेषता नहीं है 'ऑब्जेक्ट्स'

— Shek

@garnaat आपकी टिप्पणी ने उस फ़िल्टर विधि का उल्लेख करते हुए वास्तव में मेरी मदद की (मेरा कोड बहुत सरल और तेज़ हो गया) - धन्यवाद!

— एडवर्ड डिक्सन

मैं objectचर नाम के रूप में उपयोग करने के खिलाफ सलाह दूंगा क्योंकि यह वैश्विक प्रकार को छाया देगा object।

— ऑलिलैंड

Answer 2

यह एक 'ls' के समान है लेकिन यह उपसर्ग फ़ोल्डर कन्वेंशन को ध्यान में नहीं रखता है और बाल्टी में वस्तुओं को सूचीबद्ध करेगा। यह उपसर्गों को फ़िल्टर करने के लिए पाठक के ऊपर छोड़ दिया जाता है जो कुंजी नाम का हिस्सा हैं।

पायथन 2 में:

from boto.s3.connection import S3Connection

conn = S3Connection() # assumes boto.cfg setup
bucket = conn.get_bucket('bucket_name')
for obj in bucket.get_all_keys():
    print(obj.key)

पायथन 3 में:

from boto3 import client

conn = client('s3')  # again assumes boto.cfg setup, assume AWS S3
for key in conn.list_objects(Bucket='bucket_name')['Contents']:
    print(key['Key'])

Comments

यदि आप उपसर्ग का उपयोग करना चाहते हैं, तो आप इसे इस तरह से कर सकते हैं:conn.list_objects(Bucket='bucket_name', Prefix='prefix_string')['Contents']

— markonovak

यह केवल पहले 1000 कुंजी सूचीबद्ध करता है। डॉकस्ट्रिंग से: "एक बाल्टी में वस्तुओं के कुछ या सभी (1000 तक) लौटाता है।" इसके अलावा, यह अनुशंसा की जाती है कि आप list_objects के बजाय list_objects_v2 का उपयोग करें (हालाँकि, यह केवल पहले 1000 कुंजी देता है)।

— ब्रेट विडमियर

Paginators

— v25

Answer 3

मैं मान रहा हूं कि आपने प्रमाणीकरण अलग से कॉन्फ़िगर किया है।

import boto3
s3 = boto3.resource('s3')

my_bucket = s3.Bucket('bucket_name')

for file in my_bucket.objects.all():
    print(file.key)

Answer 4

यदि आप ACCESS और SECRET कुंजियाँ पास करना चाहते हैं (जो आपको नहीं करनी चाहिए, क्योंकि यह सुरक्षित नहीं है):

from boto3.session import Session

ACCESS_KEY='your_access_key'
SECRET_KEY='your_secret_key'

session = Session(aws_access_key_id=ACCESS_KEY,
                  aws_secret_access_key=SECRET_KEY)
s3 = session.resource('s3')
your_bucket = s3.Bucket('your_bucket')

for s3_file in your_bucket.objects.all():
    print(s3_file.key)

Comments

यह ~ / .aws / क्रेडेंशियल्स पर क्रेडेंशियल फ़ाइल रखने की तुलना में कम सुरक्षित है। हालांकि यह एक वैध समाधान है।

— नू एवरेस्ट

इसके लिए स्रोत नियंत्रण के लिए रहस्य करने की आवश्यकता होगी। अच्छा नही।

— ग्रन्थ jan ’१41

यह उत्तर गैर-प्रासंगिक प्रमाणीकरण पद्धति को जोड़ने के दौरान वस्तुओं को सूचीबद्ध करने के एपीआई / यांत्रिकी के बारे में कुछ नहीं जोड़ता है जो सभी बोटो संसाधनों के लिए सामान्य है और एक बुरा अभ्यास सुरक्षा वार है

— फ्रोके

सुरक्षा के बारे में जवाब में एक अस्वीकरण जोड़ा गया।

— rjurney

क्या होगा यदि कुंजी तिजोरी (हैशिकॉर्प) की तरह कुंजी / गुप्त प्रबंधन प्रणाली द्वारा आपूर्ति की गई थी - जो केवल ~ / .aws / क्रेडेंशियल पर क्रेडेंशियल फ़ाइल रखने से बेहतर नहीं होगी?

— सनीअक

Answer 5

बड़ी कुंजी लिस्टिंग (यानी जब निर्देशिका सूची 1000 से अधिक आइटम है) को संभालने के लिए, मैंने कई कोड (पहली पंक्तियों के लिए ऊपर एमिलियो के लिए धन्यवाद) के साथ मुख्य मूल्यों (यानी फ़ाइल नाम) को जमा करने के लिए निम्नलिखित कोड का उपयोग किया। Python3 के लिए कोड है:

    from boto3  import client
    bucket_name = "my_bucket"
    prefix      = "my_key/sub_key/lots_o_files"

    s3_conn   = client('s3')  # type: BaseClient  ## again assumes boto.cfg setup, assume AWS S3
    s3_result =  s3_conn.list_objects_v2(Bucket=bucket_name, Prefix=prefix, Delimiter = "/")

    if 'Contents' not in s3_result:
        #print(s3_result)
        return []

    file_list = []
    for key in s3_result['Contents']:
        file_list.append(key['Key'])
    print(f"List count = {len(file_list)}")

    while s3_result['IsTruncated']:
        continuation_key = s3_result['NextContinuationToken']
        s3_result = s3_conn.list_objects_v2(Bucket=bucket_name, Prefix=prefix, Delimiter="/", ContinuationToken=continuation_key)
        for key in s3_result['Contents']:
            file_list.append(key['Key'])
        print(f"List count = {len(file_list)}")
    return file_list

Answer 6

मेरा s3 keysउपयोगिता फ़ंक्शन अनिवार्य रूप से @ Hephaestus के उत्तर का अनुकूलित संस्करण है:

import boto3


s3_paginator = boto3.client('s3').get_paginator('list_objects_v2')


def keys(bucket_name, prefix='/', delimiter='/', start_after=''):
    prefix = prefix[1:] if prefix.startswith(delimiter) else prefix
    start_after = (start_after or prefix) if prefix.endswith(delimiter) else start_after
    for page in s3_paginator.paginate(Bucket=bucket_name, Prefix=prefix, StartAfter=start_after):
        for content in page.get('Contents', ()):
            yield content['Key']

मेरे परीक्षणों में (बोटो 3 1.9.84), यह समकक्ष (लेकिन सरल) कोड की तुलना में काफी तेज है:

import boto3


def keys(bucket_name, prefix='/', delimiter='/'):
    prefix = prefix[1:] if prefix.startswith(delimiter) else prefix
    bucket = boto3.resource('s3').Bucket(bucket_name)
    return (_.key for _ in bucket.objects.filter(Prefix=prefix))

जैसा कि S3 UTF-8 बाइनरी सॉर्ट किए गए परिणामों की गारंटी देता है , start_afterपहले फ़ंक्शन में एक अनुकूलन जोड़ा गया है।

Comments

यह अब तक का सबसे अच्छा जवाब है। जब मैंने नीचे स्क्रॉल किया तो मैं @ हेफेस्टस के उत्तर को संशोधित कर रहा था (क्योंकि यह उच्चतम था)। यह स्वीकृत उत्तर होना चाहिए और संक्षिप्त होने के लिए अतिरिक्त अंक प्राप्त करने चाहिए। मुझे लगता है कि list()फ़ाइलों की एक सूची वापस करने के लिए दूसरे कोड से जनरेटर को लपेटने की आवश्यकता है ।

— रिचर्ड डी

@ रीचर्ड दोनों परिणाम जनरेटर लौटाते हैं। इस कोड के साथ मेरे द्वारा लक्षित कई बाल्टियों में कोड की स्मृति की तुलना में अधिक कुंजियाँ होती हैं जो एक बार में संभाल सकती हैं (उदाहरण के लिए, AWS लैम्ब्डा); मैं कुंजी का उपभोग करना पसंद करता हूं क्योंकि वे उत्पन्न होती हैं।

— शॉन ग्रीष्मकाल

Answer 7

लार्स फॉर थ्रू के माध्यम से पुनरावृत्ति करने के बजाय एक अधिक मार्मिक तरीका, आप अपनी S3 बाल्टी के अंदर सभी फाइलों वाली मूल वस्तु को भी प्रिंट कर सकते हैं:

session = Session(aws_access_key_id=aws_access_key_id,aws_secret_access_key=aws_secret_access_key)
s3 = session.resource('s3')
bucket = s3.Bucket('bucket_name')

files_in_s3 = bucket.objects.all() 
#you can print this iterable with print(list(files_in_s3))

Comments

@petezurich, क्या आप बता सकते हैं कि मेरे जवाब का इतना छोटा संपादन क्यों - मेरे जवाब की शुरुआत में "ए" को "राजधानी" के साथ "ए -2" से मेरी प्रतिष्ठा में कमी आई, हालांकि मैं आपको और मैं दोनों को सहमत कर सकता हूं। यह न केवल आपके सुधार के लिए प्रासंगिक है, बल्कि वास्तव में क्षुद्र है, तो क्या आप ऐसा नहीं कहेंगे? कृपया बचकाने संशोधनों के बजाय सामग्री पर ध्यान केंद्रित करें, सबसे ज्यादा ol'boy

— Daniel Vieira

ये दो अलग-अलग इंटरैक्शन थे। 1. मैंने आपके उत्तर को संपादित कर दिया, जो मामूली गलत वर्तनी के लिए भी अनुशंसित है। मैं सहमत हूं, कि मामूली और तुच्छ के बीच की सीमा अस्पष्ट है। मैं किसी भी पद को कम नहीं करता हूं क्योंकि मुझे त्रुटियाँ दिखाई देती हैं और मैं इस मामले में नहीं था। मैं बस उन सभी त्रुटियों को ठीक करता हूं जो मुझे दिखाई देती हैं।

— पेटीजरिच

2. मैंने आपके उत्तर को अस्वीकार कर दिया क्योंकि आपने लिखा था कि files_in_s3"सूची वस्तु" है। अजगर में ऐसी कोई बात नहीं है। बल्कि यह एक पुनरावृत्ति है और मैं आपके कोड को काम नहीं कर सकता और इसलिए इसे अस्वीकृत कर दिया गया। मैंने त्रुटि पाई और आपकी बात को देखा लेकिन मेरे पतन को पूर्ववत नहीं कर सका।

— petezurich

@petezurich कोई समस्या नहीं है, आपकी, बिंदु, सिर्फ एक बात, पायथन में एक सूची को समझा गया है, एक वस्तु है क्योंकि अजगर में सब कुछ एक वस्तु है, तो यह भी अनुसरण करता है कि एक सूची भी एक चलने योग्य है, लेकिन पहले और सबसे महत्वपूर्ण, यह एक है वस्तु! यही कारण है कि मैं आपके पतन को नहीं समझ पाया- आप नीचे कुछ ऐसा मतदान कर रहे थे जो सही था और जो काम करता था। वैसे भी, आपकी माफी के लिए धन्यवाद और सभी बेहतरीन

— डैनियल विएरा

@petezurich पाइथन में सब कुछ एक वस्तु है। "सूची ऑब्जेक्ट" पूरी तरह से स्वीकार्य है।

— ज़च गरवुड

Answer 8

ObjectSummary:

दो पहचानकर्ता हैं जो ऑब्जेक्टस्मरी से जुड़े हैं:

• bucket_name
• चाभी

boto3 S3: ऑब्जेक्टस्मरी

AWS S3 दस्तावेज़ीकरण से ऑब्जेक्ट कुंजी पर अधिक:

वस्तु की:

जब आप एक ऑब्जेक्ट बनाते हैं, तो आप उस कुंजी नाम को निर्दिष्ट करते हैं, जो बाल्टी में ऑब्जेक्ट को विशिष्ट रूप से पहचानता है। उदाहरण के लिए, अमेज़ॅन S3 कंसोल (AWS प्रबंधन कंसोल देखें) में, जब आप बाल्टी को हाइलाइट करते हैं, तो आपके बाल्टी में ऑब्जेक्ट्स की एक सूची दिखाई देती है। ये नाम ऑब्जेक्ट कुंजियाँ हैं। एक कुंजी का नाम यूनिकोड वर्णों का एक अनुक्रम है, जिसकी UTF-8 एन्कोडिंग 1024 बाइट्स लंबे समय तक है।

अमेज़ॅन एस 3 डेटा मॉडल एक सपाट संरचना है: आप एक बाल्टी बनाते हैं, और बाल्टी वस्तुओं को स्टोर करती है। सबबकेट्स या सबफ़ोल्डर्स का कोई पदानुक्रम नहीं है; हालाँकि, आप कुंजी नाम उपसर्गों और सीमांकक का उपयोग करके तार्किक पदानुक्रम का अनुमान लगा सकते हैं जैसा कि अमेज़न S3 कंसोल करता है। अमेज़ॅन S3 कंसोल फ़ोल्डर्स की अवधारणा का समर्थन करता है। मान लीजिए कि आपकी बकेट (व्यवस्थापक-निर्मित) में निम्नलिखित ऑब्जेक्ट कुंजियों के साथ चार ऑब्जेक्ट हैं:

विकास / Projects1.xls

वित्त / statement1.pdf

निजी / taxdocument.pdf

S3-dg.pdf

संदर्भ:

AWS S3: ऑब्जेक्ट कीज़

यहाँ कुछ उदाहरण कोड है जो दर्शाता है कि बाल्टी नाम और ऑब्जेक्ट कुंजी कैसे प्राप्त करें।

उदाहरण:

import boto3
from pprint import pprint

def main():

    def enumerate_s3():
        s3 = boto3.resource('s3')
        for bucket in s3.buckets.all():
             print("Name: {}".format(bucket.name))
             print("Creation Date: {}".format(bucket.creation_date))
             for object in bucket.objects.all():
                 print("Object: {}".format(object))
                 print("Object bucket_name: {}".format(object.bucket_name))
                 print("Object key: {}".format(object.key))

    enumerate_s3()


if __name__ == '__main__':
    main()

Answer 9

मैंने इसे प्रमाणीकरण विधि सहित इस तरह किया:

s3_client = boto3.client(
                's3',
                aws_access_key_id='access_key',
                aws_secret_access_key='access_key_secret',
                config=boto3.session.Config(signature_version='s3v4'),
                region_name='region'
            )

response = s3_client.list_objects(Bucket='bucket_name', Prefix=key)
if ('Contents' in response):
    # Object / key exists!
    return True
else:
    # Object / key DOES NOT exist!
    return False

Answer 10

#To print all filenames in a bucket
import boto3

s3 = boto3.client('s3')

def get_s3_keys(bucket):

    """Get a list of keys in an S3 bucket."""
    resp = s3.list_objects_v2(Bucket=bucket)
    for obj in resp['Contents']:
      files = obj['Key']
    return files


filename = get_s3_keys('your_bucket_name')

print(filename)

#To print all filenames in a certain directory in a bucket
import boto3

s3 = boto3.client('s3')

def get_s3_keys(bucket, prefix):

    """Get a list of keys in an S3 bucket."""
    resp = s3.list_objects_v2(Bucket=bucket, Prefix=prefix)
    for obj in resp['Contents']:
      files = obj['Key']
      print(files)
    return files


filename = get_s3_keys('your_bucket_name', 'folder_name/sub_folder_name/')

print(filename)

Comments

दोनों "get_s3_keys" केवल अंतिम कुंजी देता है।

— एलेक्सी वाज़नोव

यह हालांकि बाल्टी में सभी फाइलों को सूचीबद्ध करता है; सवाल यह था कि कैसे करें ls। आप ऐसा कैसे करेंगे..जल्द ही फाइलों को रूट में प्रिंट करें

— हरमन

Answer 11

उपरोक्त टिप्पणियों में से एक में @Hephaeastus के कोड में थोड़ा संशोधन के साथ, नीचे दिए गए पथ में फ़ोल्डर्स और ऑब्जेक्ट (फ़ाइलों) को सूचीबद्ध करने के लिए नीचे की विधि लिखी है। S3 ls कमांड के समान काम करता है।

from boto3 import session

def s3_ls(profile=None, bucket_name=None, folder_path=None):
    folders=[]
    files=[]
    result=dict()
    bucket_name = bucket_name
    prefix= folder_path
    session = boto3.Session(profile_name=profile)
    s3_conn   = session.client('s3')
    s3_result =  s3_conn.list_objects_v2(Bucket=bucket_name, Delimiter = "/", Prefix=prefix)
    if 'Contents' not in s3_result and 'CommonPrefixes' not in s3_result:
        return []

    if s3_result.get('CommonPrefixes'):
        for folder in s3_result['CommonPrefixes']:
            folders.append(folder.get('Prefix'))

    if s3_result.get('Contents'):
        for key in s3_result['Contents']:
            files.append(key['Key'])

    while s3_result['IsTruncated']:
        continuation_key = s3_result['NextContinuationToken']
        s3_result = s3_conn.list_objects_v2(Bucket=bucket_name, Delimiter="/", ContinuationToken=continuation_key, Prefix=prefix)
        if s3_result.get('CommonPrefixes'):
            for folder in s3_result['CommonPrefixes']:
                folders.append(folder.get('Prefix'))
        if s3_result.get('Contents'):
            for key in s3_result['Contents']:
                files.append(key['Key'])

    if folders:
        result['folders']=sorted(folders)
    if files:
        result['files']=sorted(files)
    return result

यह दिए गए मार्ग में सभी ऑब्जेक्ट्स / फ़ोल्डरों को सूचीबद्ध करता है। Folder_path को डिफ़ॉल्ट रूप से कोई भी नहीं छोड़ा जा सकता है और विधि बाल्टी की जड़ की तात्कालिक सामग्री को सूचीबद्ध करेगी।

Answer 12

यहाँ समाधान है

आयात boto3

s3 = boto3.resource ('s3')

BUCKET_NAME = 'आपका S3 बाल्टी नाम eg'deletemetesting11' ''

allFiles = s3.Bucket (BUCKET_NAME) .objects.all ()

सभी फ़ाइल में फ़ाइल के लिए: प्रिंट (file.key)

Answer 13

इसे निम्नानुसार भी किया जा सकता है:

csv_files = s3.list_objects_v2(s3_bucket_path)
    for obj in csv_files['Contents']:
        key = obj['Key']

Answer 14

तो आप aws s3 lsboto3 में बराबर के लिए पूछ रहे हैं । यह सभी शीर्ष स्तर के फ़ोल्डर्स और फ़ाइलों की सूची होगी। यह वह निकटतम है जो मुझे मिल सकता है; यह केवल शीर्ष स्तर के सभी फ़ोल्डरों को सूचीबद्ध करता है। हैरानी होती है कि इतना आसान ऑपरेशन कितना मुश्किल है।

import boto3

def s3_ls():
  s3 = boto3.resource('s3')
  bucket = s3.Bucket('example-bucket')
  result = bucket.meta.client.list_objects(Bucket=bucket.name,
                                           Delimiter='/')
  for o in result.get('CommonPrefixes'):
    print(o.get('Prefix'))