Abrufen Unterordner Namen im S3-bucket aus boto3

Unten Stück code gibt NUR den 'Unterordner' im 'Ordner' aus dem s3-bucket.

import boto3
bucket = 'my-bucket'
#Make sure you provide /in the end
prefix = 'prefix-name-with-slash/'  

client = boto3.client('s3')
result = client.list_objects(Bucket=bucket, Prefix=prefix, Delimiter='/')
for o in result.get('CommonPrefixes'):
    print 'sub folder : ', o.get('Prefix')

Weitere details finden Sie auf https://github.com/boto/boto3/issues/134

InformationsquelleAutor Dipankar

Kurze Antwort:

• Verwenden Delimiter='/'. Dies vermeidet dabei ein Rekursives listing von Ihrem Eimer. Hier einige Antworten falsch schlagen vor, eine komplette Liste und mit einigen string-manipulation zum abrufen der Verzeichnis-Namen. Dies könnte schrecklich ineffizient. Denken Sie daran, dass S3 hat praktisch keine Begrenzung der Anzahl der Objekte einen Eimer enthalten kann. Also stellen Sie sich vor, dass zwischen bar/ und foo/ Sie haben Billionen von Objekten: Sie würde warten, eine sehr lange Zeit, um ['bar/', 'foo/'].

• Verwenden Paginators. Aus dem gleichen Grund (S3 ist ein Ingenieur-Angleichung der Unendlichkeit), Sie muss Liste durch die Seiten, und vermeiden Sie die Speicherung der Liste in den Speicher. Stattdessen betrachten Sie Ihre "lister" als iterator vor, und Griff den Strom, den es produziert.

• Verwenden boto3.client, nicht boto3.Ressource. Die resource version scheint nicht zu behandeln sowie die Delimiter option. Wenn Sie eine Ressource, sagen bucket = boto3.resource('s3').Bucket(name) können Sie den entsprechenden client mit: bucket.meta.client.

Lange Antwort:

Folgende ist ein iterator, ich benutze für einfache Eimer (keine version handling).

import boto3
from collections import namedtuple
from operator import attrgetter


S3Obj = namedtuple('S3Obj', ['key', 'mtime', 'size', 'ETag'])


def s3list(bucket, path, start=None, end=None, recursive=True, list_dirs=True,
           list_objs=True, limit=None):
    """
    Iterator that lists a bucket's objects under path, (optionally) starting with
    start and ending before end.

    If recursive is False, then list only the "depth=0" items (dirs and objects).

    If recursive is True, then list recursively all objects (no dirs).

    Args:
        bucket:
            a boto3.resource('s3').Bucket().
        path:
            a directory in the bucket.
        start:
            optional: start key, inclusive (may be a relative path under path, or
            absolute in the bucket)
        end:
            optional: stop key, exclusive (may be a relative path under path, or
            absolute in the bucket)
        recursive:
            optional, default True. If True, lists only objects. If False, lists
            only depth 0 "directories" and objects.
        list_dirs:
            optional, default True. Has no effect in recursive listing. On
            non-recursive listing, if False, then directories are omitted.
        list_objs:
            optional, default True. If False, then directories are omitted.
        limit:
            optional. If specified, then lists at most this many items.

    Returns:
        an iterator of S3Obj.

    Examples:
        # set up
        >>> s3 = boto3.resource('s3')
        ... bucket = s3.Bucket(name)

        # iterate through all S3 objects under some dir
        >>> for p in s3ls(bucket, 'some/dir'):
        ...     print(p)

        # iterate through up to 20 S3 objects under some dir, starting with foo_0010
        >>> for p in s3ls(bucket, 'some/dir', limit=20, start='foo_0010'):
        ...     print(p)

        # non-recursive listing under some dir:
        >>> for p in s3ls(bucket, 'some/dir', recursive=False):
        ...     print(p)

        # non-recursive listing under some dir, listing only dirs:
        >>> for p in s3ls(bucket, 'some/dir', recursive=False, list_objs=False):
        ...     print(p)
"""
    kwargs = dict()
    if start is not None:
        if not start.startswith(path):
            start = os.path.join(path, start)
        # note: need to use a string just smaller than start, because
        # the list_object API specifies that start is excluded (the first
        # result is *after* start).
        kwargs.update(Marker=__prev_str(start))
    if end is not None:
        if not end.startswith(path):
            end = os.path.join(path, end)
    if not recursive:
        kwargs.update(Delimiter='/')
        if not path.endswith('/'):
            path += '/'
    kwargs.update(Prefix=path)
    if limit is not None:
        kwargs.update(PaginationConfig={'MaxItems': limit})

    paginator = bucket.meta.client.get_paginator('list_objects')
    for resp in paginator.paginate(Bucket=bucket.name, **kwargs):
        q = []
        if 'CommonPrefixes' in resp and list_dirs:
            q = [S3Obj(f['Prefix'], None, None, None) for f in resp['CommonPrefixes']]
        if 'Contents' in resp and list_objs:
            q += [S3Obj(f['Key'], f['LastModified'], f['Size'], f['ETag']) for f in resp['Contents']]
        # note: even with sorted lists, it is faster to sort(a+b)
        # than heapq.merge(a, b) at least up to 10K elements in each list
        q = sorted(q, key=attrgetter('key'))
        if limit is not None:
            q = q[:limit]
            limit -= len(q)
        for p in q:
            if end is not None and p.key >= end:
                return
            yield p


def __prev_str(s):
    if len(s) == 0:
        return s
    s, c = s[:-1], ord(s[-1])
    if c > 0:
        s += chr(c - 1)
    s += ''.join(['\u7FFF' for _ in range(10)])
    return s

Test:

Folgende ist hilfreich, um testen Sie das Verhalten der paginator und list_objects. Es schafft eine Reihe von Verzeichnissen und Dateien. Da die Seiten sind bis zu 1000 Einträge, verwenden wir ein Vielfaches für Verzeichnisse und Dateien. dirs enthält nur Verzeichnisse (jeweils ein Objekt). mixed enthält eine Mischung von dirs und Objekte, mit einem Verhältnis von 2 Objekten für jede dir (plus ein Objekt unter dir, natürlich; S3 speichert nur Objekte).

import concurrent
def genkeys(top='tmp/test', n=2000):
    for k in range(n):
        if k % 100 == 0:
            print(k)
        for name in [
            os.path.join(top, 'dirs', f'{k:04d}_dir', 'foo'),
            os.path.join(top, 'mixed', f'{k:04d}_dir', 'foo'),
            os.path.join(top, 'mixed', f'{k:04d}_foo_a'),
            os.path.join(top, 'mixed', f'{k:04d}_foo_b'),
        ]:
            yield name


with concurrent.futures.ThreadPoolExecutor(max_workers=32) as executor:
    executor.map(lambda name: bucket.put_object(Key=name, Body='hi\n'.encode()), genkeys())

Die resultierende Struktur ist:

./dirs/0000_dir/foo
./dirs/0001_dir/foo
./dirs/0002_dir/foo
...
./dirs/1999_dir/foo
./mixed/0000_dir/foo
./mixed/0000_foo_a
./mixed/0000_foo_b
./mixed/0001_dir/foo
./mixed/0001_foo_a
./mixed/0001_foo_b
./mixed/0002_dir/foo
./mixed/0002_foo_a
./mixed/0002_foo_b
...
./mixed/1999_dir/foo
./mixed/1999_foo_a
./mixed/1999_foo_b

Mit ein wenig verarzten den code oben für s3list zu prüfen die Antworten von der paginator ist, können Sie beobachten einige lustige Fakten:

• Den Marker ist wirklich exklusiv. Angesichts Marker=topdir + 'mixed/0500_foo_a' wird die Auflistung beginnen nach, der Schlüssel (wie in der AmazonS3 API), d.h., mit .../mixed/0500_foo_b. Das ist der Grund für __prev_str().

• Mit Delimiter, bei der Auflistung mixed/ jede Antwort aus der paginator enthält 666 keys und 334 häufige Präfixe. Es ist ziemlich gut, nicht Gebäude enorme Reaktionen.

• Dagegen bei der Auflistung dirs/ jede Antwort aus der paginator enthält die 1000 häufigsten Präfixe (und keine Tasten).

• Passieren einer Grenze in form von PaginationConfig={'MaxItems': limit} Grenzen, nur die Anzahl der Schlüssel, nicht die gemeinsame Präfixe. Wir beschäftigen uns mit, dass durch das weitere kürzen der stream von unseren iterator.

InformationsquelleAutor Pierre D

den neuesten BOTO3 Dokumentation empfiehlt jetzt mit list_objects_v2
http://boto3.readthedocs.io/en/latest/reference/services/s3.html#S3.Client.list_objects_v2

InformationsquelleAutor Sameer Girolkar

Folgende Werke für mich... S3-Objekte:

s3://bucket/
    form1/
       section11/
          file111
          file112
       section12/
          file121
    form2/
       section21/
          file211
          file112
       section22/
          file221
          file222
          ...
      ...
   ...

Mit:

from boto3.session import Session
s3client = session.client('s3')
resp = s3client.list_objects(Bucket=bucket, Prefix='', Delimiter="/")
forms = [x['Prefix'] for x in resp['CommonPrefixes']] 

erhalten wir:

form1/
form2/
...

Mit:

resp = s3client.list_objects(Bucket=bucket, Prefix='form1/', Delimiter="/")
sections = [x['Prefix'] for x in resp['CommonPrefixes']] 

erhalten wir:

form1/section11/
form1/section12/

InformationsquelleAutor cem

Erstens, es gibt keine echten Ordner-Konzept in S3.
Sie können definitiv haben ein Datei @ '/folder/subfolder/myfile.txt' und keine Ordner noch Unterordner.

Zu "simulieren" einen Ordner in S3, müssen Sie erstellen eine leere Datei mit einem '/' am Ende des namens (siehe Amazon S3 boto - how, um einen Ordner zu erstellen?)

Für Ihr problem, sollten Sie wahrscheinlich verwenden Sie die Methode get_all_keys mit den 2 Parametern : prefix und delimiter

https://github.com/boto/boto/blob/develop/boto/s3/bucket.py#L427

for key in bucket.get_all_keys(prefix='first-level/', delimiter='/'):
    print(key.name)

InformationsquelleAutor Pirheas