Lister les objets

Cette page vous explique comment répertorier les objets stockés dans vos buckets Cloud Storage, classés par ordre alphabétique dans la liste.

Avant de commencer

Pour obtenir les autorisations nécessaires pour lister des objets, demandez à votre administrateur de vous accorder le rôle IAM "Lecteur des objets Storage" (roles/storage.objectViewer) sur le bucket contenant les objets que vous souhaitez lister.

Si vous souhaitez renvoyer des LCA d'objets dans le cadre de votre requête ou utiliser la console Google Cloud pour effectuer les tâches décrites sur cette page, vous devez disposer des rôles alternatifs suivants :

• Si vous souhaitez renvoyer des LCA d'objets dans le cadre de votre requête, demandez à votre administrateur de vous attribuer le rôle "Administrateur des objets Storage" (roles/storage.objectAdmin) au lieu du rôle "Lecteur des objets Storage" (roles/storage.objectViewer).

• Si vous prévoyez d'utiliser la console Google Cloud pour effectuer les tâches de cette page, demandez à votre administrateur de vous accorder le rôle "Administrateur de l'espace de stockage" (roles/storage.admin) au lieu du rôle "Lecteur des objets Storage" (roles/storage.objectViewer).

  Vous pouvez également demander à votre administrateur de vous accorder le rôle de base Lecteur (roles/viewer) en plus du rôle "Lecteur des objets Storage" (roles/storage.objectViewer).

Ces rôles contiennent les autorisations requises pour regrouper des objets. Pour afficher les autorisations exactes requises, développez la section Autorisations requises :

Autorisations requises

• storage.objects.list
• storage.objects.getIamPolicy
  • Cette autorisation n'est nécessaire que si vous souhaitez renvoyer des LCA d'objets.
• storage.buckets.list
  • Cette autorisation n'est nécessaire que si vous souhaitez utiliser la console Google Cloud pour effectuer les tâches décrites sur cette page.

Vous pouvez également obtenir ces autorisations en utilisant d'autres rôles prédéfinis ou des rôles personnalisés.

Pour en savoir plus sur l'attribution de rôles pour des buckets, consultez la page Utiliser IAM avec des buckets.

Répertorier les objets d'un bucket

Pour répertorier les objets d'un bucket, procédez comme suit :

Console

1. Dans la console Google Cloud, accédez à la page Buckets Cloud Storage.
   

   Accéder à la page "Buckets"

2. Dans la liste des buckets, cliquez sur le nom du bucket dont vous souhaitez afficher le contenu.

3. (Facultatif) Utilisez le filtrage pour affiner les résultats de votre liste.

Ligne de commande

Exécutez la commande gcloud storage ls avec l'option --recursive :

gcloud storage ls --recursive gs://BUCKET_NAME/**

Où :

• BUCKET_NAME correspond au nom du bucket dont vous souhaitez répertorier les objets. Par exemple, my-bucket.

La réponse est semblable à ceci :

gs://my-bucket/cats.jpeg
gs://my-bucket/dogs.jpeg
gs://my-bucket/thesis.txt
...

Remarque : Vous pouvez utiliser un préfixe dans votre requête de création de liste pour limiter les résultats aux objets comportant le préfixe spécifié :

gcloud storage ls --recursive gs://BUCKET_NAME/PREFIX**

Par exemple, gcloud storage ls --recursive gs://my-bucket/p** renvoie :

gs://my-bucket/puppy.png
gs://my-bucket/pug.jpg
gs://my-bucket/pets/dog.png
...

Bibliothèques clientes

C++

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage C++.

Pour vous authentifier auprès de Cloud Storage, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.

L'exemple suivant répertorie tous les objets d'un bucket :

namespace gcs = ::google::cloud::storage;
[](gcs::Client client, std::string const& bucket_name) {
  for (auto&& object_metadata : client.ListObjects(bucket_name)) {
    if (!object_metadata) throw std::move(object_metadata).status();

    std::cout << "bucket_name=" << object_metadata->bucket()
              << ", object_name=" << object_metadata->name() << "\n";
  }
}

L'exemple suivant répertorie les objets ayant un préfixe donné :

namespace gcs = ::google::cloud::storage;
[](gcs::Client client, std::string const& bucket_name,
   std::string const& bucket_prefix) {
  for (auto&& object_metadata :
       client.ListObjects(bucket_name, gcs::Prefix(bucket_prefix))) {
    if (!object_metadata) throw std::move(object_metadata).status();

    std::cout << "bucket_name=" << object_metadata->bucket()
              << ", object_name=" << object_metadata->name() << "\n";
  }
}

C#

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage C#.

Pour vous authentifier auprès de Cloud Storage, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.

L'exemple suivant répertorie tous les objets d'un bucket :

using Google.Cloud.Storage.V1;
using System;
using System.Collections.Generic;

public class ListFilesSample
{
    public IEnumerable<Google.Apis.Storage.v1.Data.Object> ListFiles(
        string bucketName = "your-unique-bucket-name")
    {
        var storage = StorageClient.Create();
        var storageObjects = storage.ListObjects(bucketName);
        Console.WriteLine($"Files in bucket {bucketName}:");
        foreach (var storageObject in storageObjects)
        {
            Console.WriteLine(storageObject.Name);
        }

        return storageObjects;
    }
}

L'exemple suivant répertorie les objets ayant un préfixe donné :

using Google.Cloud.Storage.V1;
using System;
using System.Collections.Generic;

public class ListFilesWithPrefixSample
{
    /// <summary>
    /// Prefixes and delimiters can be used to emulate directory listings.
    /// Prefixes can be used to filter objects starting with prefix.
    /// The delimiter argument can be used to restrict the results to only the
    /// objects in the given "directory". Without the delimiter, the entire  tree
    /// under the prefix is returned.
    /// For example, given these objects:
    ///   a/1.txt
    ///   a/b/2.txt
    ///
    /// If you just specify prefix="a/", you'll get back:
    ///   a/1.txt
    ///   a/b/2.txt
    ///
    /// However, if you specify prefix="a/" and delimiter="/", you'll get back:
    ///   a/1.txt
    /// </summary>
    /// <param name="bucketName">The bucket to list the objects from.</param>
    /// <param name="prefix">The prefix to match. Only objects with names that start with this string will
    /// be returned. This parameter may be null or empty, in which case no filtering
    /// is performed.</param>
    /// <param name="delimiter">Used to list in "directory mode". Only objects whose names (aside from the prefix)
    /// do not contain the delimiter will be returned.</param>
    public IEnumerable<Google.Apis.Storage.v1.Data.Object> ListFilesWithPrefix(
        string bucketName = "your-unique-bucket-name",
        string prefix = "your-prefix",
        string delimiter = "your-delimiter")
    {
        var storage = StorageClient.Create();
        var options = new ListObjectsOptions { Delimiter = delimiter };
        var storageObjects = storage.ListObjects(bucketName, prefix, options);
        Console.WriteLine($"Objects in bucket {bucketName} with prefix {prefix}:");
        foreach (var storageObject in storageObjects)
        {
            Console.WriteLine(storageObject.Name);
        }
        return storageObjects;
    }
}

Go

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage Go.

Pour vous authentifier auprès de Cloud Storage, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.

L'exemple suivant répertorie tous les objets d'un bucket :

import (
	"context"
	"fmt"
	"io"
	"time"

	"cloud.google.com/go/storage"
	"google.golang.org/api/iterator"
)

// listFiles lists objects within specified bucket.
func listFiles(w io.Writer, bucket string) error {
	// bucket := "bucket-name"
	ctx := context.Background()
	client, err := storage.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("storage.NewClient: %w", err)
	}
	defer client.Close()

	ctx, cancel := context.WithTimeout(ctx, time.Second*10)
	defer cancel()

	it := client.Bucket(bucket).Objects(ctx, nil)
	for {
		attrs, err := it.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			return fmt.Errorf("Bucket(%q).Objects: %w", bucket, err)
		}
		fmt.Fprintln(w, attrs.Name)
	}
	return nil
}

L'exemple suivant répertorie les objets ayant un préfixe donné :

import (
	"context"
	"fmt"
	"io"
	"time"

	"cloud.google.com/go/storage"
	"google.golang.org/api/iterator"
)

// listFilesWithPrefix lists objects using prefix and delimeter.
func listFilesWithPrefix(w io.Writer, bucket, prefix, delim string) error {
	// bucket := "bucket-name"
	// prefix := "/foo"
	// delim := "_"
	ctx := context.Background()
	client, err := storage.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("storage.NewClient: %w", err)
	}
	defer client.Close()

	// Prefixes and delimiters can be used to emulate directory listings.
	// Prefixes can be used to filter objects starting with prefix.
	// The delimiter argument can be used to restrict the results to only the
	// objects in the given "directory". Without the delimiter, the entire tree
	// under the prefix is returned.
	//
	// For example, given these blobs:
	//   /a/1.txt
	//   /a/b/2.txt
	//
	// If you just specify prefix="a/", you'll get back:
	//   /a/1.txt
	//   /a/b/2.txt
	//
	// However, if you specify prefix="a/" and delim="/", you'll get back:
	//   /a/1.txt
	ctx, cancel := context.WithTimeout(ctx, time.Second*10)
	defer cancel()

	it := client.Bucket(bucket).Objects(ctx, &storage.Query{
		Prefix:    prefix,
		Delimiter: delim,
	})
	for {
		attrs, err := it.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			return fmt.Errorf("Bucket(%q).Objects(): %w", bucket, err)
		}
		fmt.Fprintln(w, attrs.Name)
	}
	return nil
}

Java

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage Java.

Pour vous authentifier auprès de Cloud Storage, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.

L'exemple suivant répertorie tous les objets d'un bucket :

import com.google.api.gax.paging.Page;
import com.google.cloud.storage.Blob;
import com.google.cloud.storage.Storage;
import com.google.cloud.storage.StorageOptions;

public class ListObjects {
  public static void listObjects(String projectId, String bucketName) {
    // The ID of your GCP project
    // String projectId = "your-project-id";

    // The ID of your GCS bucket
    // String bucketName = "your-unique-bucket-name";

    Storage storage = StorageOptions.newBuilder().setProjectId(projectId).build().getService();
    Page<Blob> blobs = storage.list(bucketName);

    for (Blob blob : blobs.iterateAll()) {
      System.out.println(blob.getName());
    }
  }
}

L'exemple suivant répertorie les objets ayant un préfixe donné :

import com.google.api.gax.paging.Page;
import com.google.cloud.storage.Blob;
import com.google.cloud.storage.Storage;
import com.google.cloud.storage.StorageOptions;

public class ListObjectsWithPrefix {
  public static void listObjectsWithPrefix(
      String projectId, String bucketName, String directoryPrefix) {
    // The ID of your GCP project
    // String projectId = "your-project-id";

    // The ID of your GCS bucket
    // String bucketName = "your-unique-bucket-name";

    // The directory prefix to search for
    // String directoryPrefix = "myDirectory/"

    Storage storage = StorageOptions.newBuilder().setProjectId(projectId).build().getService();
    /**
     * Using the Storage.BlobListOption.currentDirectory() option here causes the results to display
     * in a "directory-like" mode, showing what objects are in the directory you've specified, as
     * well as what other directories exist in that directory. For example, given these blobs:
     *
     * <p>a/1.txt a/b/2.txt a/b/3.txt
     *
     * <p>If you specify prefix = "a/" and don't use Storage.BlobListOption.currentDirectory(),
     * you'll get back:
     *
     * <p>a/1.txt a/b/2.txt a/b/3.txt
     *
     * <p>However, if you specify prefix = "a/" and do use
     * Storage.BlobListOption.currentDirectory(), you'll get back:
     *
     * <p>a/1.txt a/b/
     *
     * <p>Because a/1.txt is the only file in the a/ directory and a/b/ is a directory inside the
     * /a/ directory.
     */
    Page<Blob> blobs =
        storage.list(
            bucketName,
            Storage.BlobListOption.prefix(directoryPrefix),
            Storage.BlobListOption.currentDirectory());

    for (Blob blob : blobs.iterateAll()) {
      System.out.println(blob.getName());
    }
  }
}

Node.js

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage Node.js.

Pour vous authentifier auprès de Cloud Storage, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.

L'exemple suivant répertorie tous les objets d'un bucket :

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// The ID of your GCS bucket
// const bucketName = 'your-unique-bucket-name';

// Imports the Google Cloud client library
const {Storage} = require('@google-cloud/storage');

// Creates a client
const storage = new Storage();

async function listFiles() {
  // Lists files in the bucket
  const [files] = await storage.bucket(bucketName).getFiles();

  console.log('Files:');
  files.forEach(file => {
    console.log(file.name);
  });
}

listFiles().catch(console.error);

L'exemple suivant répertorie les objets ayant un préfixe donné :

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// The ID of your GCS bucket
// const bucketName = 'your-unique-bucket-name';

// The directory prefix to search for
// const prefix = 'myDirectory/';

// The delimiter to use
// const delimiter = '/';

// Imports the Google Cloud client library
const {Storage} = require('@google-cloud/storage');

// Creates a client
const storage = new Storage();

async function listFilesByPrefix() {
  /**
   * This can be used to list all blobs in a "folder", e.g. "public/".
   *
   * The delimiter argument can be used to restrict the results to only the
   * "files" in the given "folder". Without the delimiter, the entire tree under
   * the prefix is returned. For example, given these blobs:
   *
   *   /a/1.txt
   *   /a/b/2.txt
   *
   * If you just specify prefix = 'a/', you'll get back:
   *
   *   /a/1.txt
   *   /a/b/2.txt
   *
   * However, if you specify prefix='a/' and delimiter='/', you'll get back:
   *
   *   /a/1.txt
   */
  const options = {
    prefix: prefix,
  };

  if (delimiter) {
    options.delimiter = delimiter;
  }

  // Lists files in the bucket, filtered by a prefix
  const [files] = await storage.bucket(bucketName).getFiles(options);

  console.log('Files:');
  files.forEach(file => {
    console.log(file.name);
  });
}

listFilesByPrefix().catch(console.error);

PHP

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage PHP.

Pour vous authentifier auprès de Cloud Storage, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.

L'exemple suivant répertorie tous les objets d'un bucket :

use Google\Cloud\Storage\StorageClient;

/**
 * List Cloud Storage bucket objects.
 *
 * @param string $bucketName The name of your Cloud Storage bucket.
 *        (e.g. 'my-bucket')
 */
function list_objects(string $bucketName): void
{
    $storage = new StorageClient();
    $bucket = $storage->bucket($bucketName);
    foreach ($bucket->objects() as $object) {
        printf('Object: %s' . PHP_EOL, $object->name());
    }
}

L'exemple suivant répertorie les objets ayant un préfixe donné :

use Google\Cloud\Storage\StorageClient;

/**
 * List Cloud Storage bucket objects with specified prefix.
 *
 * @param string $bucketName The name of your Cloud Storage bucket.
 *        (e.g. 'my-bucket')
 * @param string $directoryPrefix the prefix to use in the list objects API call.
 *        (e.g. 'myDirectory/')
 */
function list_objects_with_prefix(string $bucketName, string $directoryPrefix): void
{
    $storage = new StorageClient();
    $bucket = $storage->bucket($bucketName);
    $options = ['prefix' => $directoryPrefix];
    foreach ($bucket->objects($options) as $object) {
        printf('Object: %s' . PHP_EOL, $object->name());
    }
}

Python

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage Python.

Pour vous authentifier auprès de Cloud Storage, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.

L'exemple suivant répertorie tous les objets d'un bucket :

from google.cloud import storage


def list_blobs(bucket_name):
    """Lists all the blobs in the bucket."""
    # bucket_name = "your-bucket-name"

    storage_client = storage.Client()

    # Note: Client.list_blobs requires at least package version 1.17.0.
    blobs = storage_client.list_blobs(bucket_name)

    # Note: The call returns a response only when the iterator is consumed.
    for blob in blobs:
        print(blob.name)

L'exemple suivant répertorie les objets ayant un préfixe donné :

from google.cloud import storage


def list_blobs_with_prefix(bucket_name, prefix, delimiter=None):
    """Lists all the blobs in the bucket that begin with the prefix.

    This can be used to list all blobs in a "folder", e.g. "public/".

    The delimiter argument can be used to restrict the results to only the
    "files" in the given "folder". Without the delimiter, the entire tree under
    the prefix is returned. For example, given these blobs:

        a/1.txt
        a/b/2.txt

    If you specify prefix ='a/', without a delimiter, you'll get back:

        a/1.txt
        a/b/2.txt

    However, if you specify prefix='a/' and delimiter='/', you'll get back
    only the file directly under 'a/':

        a/1.txt

    As part of the response, you'll also get back a blobs.prefixes entity
    that lists the "subfolders" under `a/`:

        a/b/
    """

    storage_client = storage.Client()

    # Note: Client.list_blobs requires at least package version 1.17.0.
    blobs = storage_client.list_blobs(bucket_name, prefix=prefix, delimiter=delimiter)

    # Note: The call returns a response only when the iterator is consumed.
    print("Blobs:")
    for blob in blobs:
        print(blob.name)

    if delimiter:
        print("Prefixes:")
        for prefix in blobs.prefixes:
            print(prefix)

Ruby

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage Ruby.

Pour vous authentifier auprès de Cloud Storage, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.

L'exemple suivant répertorie tous les objets d'un bucket :

def list_files bucket_name:
  # The ID of your GCS bucket
  # bucket_name = "your-unique-bucket-name"

  require "google/cloud/storage"

  storage = Google::Cloud::Storage.new
  bucket  = storage.bucket bucket_name

  bucket.files.each do |file|
    puts file.name
  end
end

L'exemple suivant répertorie les objets ayant un préfixe donné :

def list_files_with_prefix bucket_name:, prefix:, delimiter: nil
  # Lists all the files in the bucket that begin with the prefix.
  #
  # This can be used to list all files in a "folder", e.g. "public/".
  #
  # The delimiter argument can be used to restrict the results to only the
  # "files" in the given "folder". Without the delimiter, the entire tree under
  # the prefix is returned. For example, given these files:
  #
  #     a/1.txt
  #     a/b/2.txt
  #
  # If you just specify `prefix: "a"`, you will get back:
  #
  #     a/1.txt
  #     a/b/2.txt
  #
  # However, if you specify `prefix: "a"` and `delimiter: "/"`, you will get back:
  #
  #     a/1.txt

  # The ID of your GCS bucket
  # bucket_name = "your-unique-bucket-name"

  # The directory prefix to search for
  # prefix = "a"

  # The delimiter to be used to restrict the results
  # delimiter = "/"

  require "google/cloud/storage"

  storage = Google::Cloud::Storage.new
  bucket  = storage.bucket bucket_name
  files   = bucket.files prefix: prefix, delimiter: delimiter

  files.each do |file|
    puts file.name
  end
end

API REST

API JSON

1. Obtenez un jeton d'autorisation d'accès sur la page OAuth 2.0 Playground. Configurez Playground pour utiliser vos propres identifiants OAuth. Pour obtenir des instructions, consultez la page Authentification des API.

2. Utilisez cURL pour appeler l'API JSON avec une requête permettant de répertorier les objets :

   curl -X GET -H "Authorization: Bearer OAUTH2_TOKEN" \
     "https://storage.googleapis.com/storage/v1/b/BUCKET_NAME/o"

   Où :

   • OAUTH2_TOKEN correspond au jeton d'accès que vous avez généré à l'étape 1 ;
   • BUCKET_NAME correspond au nom du bucket dont vous souhaitez répertorier les objets. Par exemple, my-bucket.

   Vous pouvez utiliser le paramètre de requête includeFoldersAsPrefixes=True pour renvoyer des dossiers gérés dans les résultats de votre liste. Lorsque vous utilisez le paramètre includeFoldersAsPrefixes, le paramètre delimiter doit être défini sur /.

   Pour renvoyer des LCA d'objets, ajoutez le paramètre de requête projection avec la valeur full à votre requête. Notez que les LCA sont désactivées et ne peuvent pas être renvoyées si l'accès uniforme au niveau du bucket est activé sur ce bucket.

API XML

1. Obtenez un jeton d'autorisation d'accès sur la page OAuth 2.0 Playground. Configurez Playground pour utiliser vos propres identifiants OAuth. Pour obtenir des instructions, consultez la page Authentification des API.

2. Utilisez cURL pour appeler l'API XML avec une requête de bucket GET :

   curl -X GET -H "Authorization: Bearer OAUTH2_TOKEN" \
     "https://storage.googleapis.com/BUCKET_NAME?list-type=2"

   Où :

   • OAUTH2_TOKEN correspond au jeton d'accès que vous avez généré à l'étape 1 ;
   • BUCKET_NAME correspond au nom du bucket dont vous souhaitez répertorier les objets. Par exemple, my-bucket.

   Vous pouvez utiliser un paramètre de chaîne de requête prefix=PREFIX pour limiter les résultats aux objets comportant le préfixe spécifié.

Filtrer des objets

Console

Pour filtrer des objets à l'aide de la console Google Cloud, utilisez le champ Filtrer de la page Détails du bucket.

Ligne de commande

Lorsque vous répertoriez des objets à l'aide de Google Cloud CLI, vous pouvez utiliser des caractères génériques pour filtrer les objets commençant par un préfixe spécifié ou se terminant par un suffixe spécifié. Par exemple, la commande suivante correspond aux objets .png commençant par image :

gcloud storage ls gs://my-bucket/image*.png

Pour en savoir plus sur le filtrage à l'aide de Google Cloud CLI, consultez la documentation de gcloud storage ls.

API REST

API JSON

Lorsque vous répertoriez des objets à l'aide de l'API JSON Cloud Storage, vous pouvez utiliser les paramètres de chaîne de requête prefix ou matchGlob pour filtrer vos résultats. Pour en savoir plus sur l'utilisation de ces paramètres de chaîne de requête, consultez la documentation de référence sur l'API JSON pour la liste des objets.

Filtrer par préfixe

Vous pouvez utiliser le paramètre prefix=PREFIX ou le paramètre de chaîne de requête pour limiter les résultats aux objets ou aux dossiers gérés portant le préfixe spécifié. Par exemple, pour répertorier tous les objets du bucket my-bucket avec le préfixe folder/subfolder/, exécutez une requête de liste d'objets en utilisant l'URL "https://storage.googleapis.com/storage/v1/b/my-bucket?prefix=folder/subfolder/".

Utilisez la commande prefix pour répertorier le contenu d'un dossier géré lorsque vous êtes uniquement autorisé à répertorier les objets dans un dossier géré, mais pas dans l'ensemble du bucket. Par exemple, supposons que vous disposiez du rôle IAM de lecteur des objets de l'espace de stockage (roles/storage.objectViewer) pour le dossier géré my-bucket/my-managed-folder-a/, mais pas pour le dossier géré my-bucket/my-managed-folder-b/. Pour ne renvoyer que les objets de my-managed-folder-a, vous pouvez spécifier prefix=my-managed-folder-a/.

Lorsque vous limitez les résultats à un dossier géré et aux objets qu'il contient, vous devez terminer PREFIX par / (par exemple, prefix=my-managed-folder/). Sinon, les résultats peuvent également inclure des objets adjacents au dossier géré. Dans cet exemple, vous disposez d'un bucket contenant les objets suivants :

• my-bucket/abc.txt
• my-bucket/abc/object.txt

Si vous spécifiez prefix=abc/, vous pouvez renvoyer les objets my-bucket/abc/object.txt, tandis que la spécification prefix=abc peut renvoyer à la fois my-bucket/abc.txt et my-bucket/abc/object.txt.

Filtrer par expression glob

Le paramètre de chaîne de requête matchGlob=GLOB_PATTERN permet de filtrer les résultats en fonction des objets correspondant à une expression glob spécifique. Par exemple, matchGlob=**.jpeg peut être utilisé pour correspondre à tous les objets dont le nom se termine par .jpeg.

Les requêtes qui utilisent le paramètre matchGlob échouent si elles incluent également un paramètre delimiter défini sur une valeur autre que /.

Étapes suivantes

• Téléchargez un objet se trouvant dans votre bucket.
• Consultez et modifiez les métadonnées d'objet.
• Supprimez des objets du bucket.
• Découvrez comment paginer les résultats.