Elenco degli oggetti

Questa pagina mostra come elencare gli oggetti archiviati in Cloud Storage bucket, che sono ordinati nell'elenco lessicograficamente per nome.

Prima di iniziare

Per ottenere le autorizzazioni necessarie per elencare gli oggetti, chiedi all'amministratore per concederti il visualizzatore oggetti Storage (roles/storage.objectViewer) ruolo IAM per il bucket che contiene gli oggetti da dall'elenco di lettura.

Se vuoi restituire gli ACL degli oggetti come parte della tua richiesta o utilizza il metodo Console Google Cloud per eseguire le attività in questa pagina, avrai bisogno di un'alternativa ruoli:

• Se vuoi restituire gli ACL degli oggetti come parte della richiesta, chiedi che ti conceda il ruolo di Amministratore oggetti Storage (roles/storage.objectAdmin) anziché Visualizzatore oggetti Storage (roles/storage.objectViewer).

• Se prevedi di utilizzare la console Google Cloud per eseguire le attività descritte in questa pagina, chiedi all'amministratore di concederti il ruolo di amministratore Storage (roles/storage.admin) anziché il ruolo Visualizzatore oggetti Storage (roles/storage.objectViewer).

  In alternativa, puoi chiedere all'amministratore di concederti il ruolo Visualizzatore (roles/viewer) ruolo di base oltre al Visualizzatore oggetti Storage (roles/storage.objectViewer).

Questi ruoli contengono le autorizzazioni necessarie per elencare gli oggetti. Per vedere l'esatto autorizzazioni richieste, espandi la sezione Autorizzazioni obbligatorie:

Autorizzazioni obbligatorie

• storage.objects.list
• storage.objects.getIamPolicy
  • Questa autorizzazione è necessaria solo se vuoi restituire gli ACL degli oggetti
• storage.buckets.list
  • Questa autorizzazione è necessaria solo se vuoi utilizzare la console Google Cloud per eseguire le attività in questa pagina.

Puoi ottenere queste autorizzazioni anche con altri ruoli predefiniti o ruoli personalizzati.

Per informazioni sulla concessione dei ruoli per i bucket, consulta Utilizzare IAM con i bucket.

Elenca gli oggetti in un bucket

Completa i seguenti passaggi per elencare gli oggetti in un bucket:

Console

1. Nella console Google Cloud, vai alla pagina Bucket di Cloud Storage.
   

   Vai a Bucket

2. Nell'elenco dei bucket, fai clic sul nome del bucket di cui che vuoi visualizzare.

3. (Facoltativo) Utilizza filtri e ordinamenti per limitare e organizzare la i risultati nel tuo elenco.

Riga di comando

Utilizza il comando gcloud storage ls con --recursive Segnala:

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

Dove:

• BUCKET_NAME è il nome del bucket la cui gli oggetti che vuoi elencare. Ad esempio, my-bucket.

La risposta è simile al seguente esempio:

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

Nota: puoi utilizzare un prefisso nella richiesta di scheda per limitare i risultati agli oggetti che hanno il prefisso specificato:

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

Ad esempio, gcloud storage ls --recursive gs://my-bucket/p** restituisce:

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

Librerie client

C++

Per ulteriori informazioni, consulta API Cloud Storage C++ documentazione di riferimento.

Per eseguire l'autenticazione su Cloud Storage, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale.

Nell'esempio seguente sono elencati tutti gli oggetti in 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";
  }
}

Nell'esempio seguente sono elencati gli oggetti con un determinato prefisso:

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#

Per ulteriori informazioni, consulta API Cloud Storage C# documentazione di riferimento.

Per eseguire l'autenticazione su Cloud Storage, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale.

Nell'esempio seguente sono elencati tutti gli oggetti in 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;
    }
}

Nell'esempio seguente sono elencati gli oggetti con un determinato prefisso:

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

Per ulteriori informazioni, consulta API Cloud Storage Go documentazione di riferimento.

Per eseguire l'autenticazione su Cloud Storage, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale.

Nell'esempio seguente sono elencati tutti gli oggetti in 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
}

Nell'esempio seguente sono elencati gli oggetti con un determinato prefisso:

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

Per ulteriori informazioni, consulta API Cloud Storage Java documentazione di riferimento.

Per eseguire l'autenticazione su Cloud Storage, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale.

Nell'esempio seguente sono elencati tutti gli oggetti in 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());
    }
  }
}

Nell'esempio seguente sono elencati gli oggetti con un determinato prefisso:

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

Per ulteriori informazioni, consulta API Cloud Storage Node.js documentazione di riferimento.

Per eseguire l'autenticazione su Cloud Storage, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale.

Nell'esempio seguente sono elencati tutti gli oggetti in 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);

Nell'esempio seguente sono elencati gli oggetti con un determinato prefisso:

/**
 * 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

Per ulteriori informazioni, consulta API Cloud Storage PHP documentazione di riferimento.

Per eseguire l'autenticazione su Cloud Storage, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale.

Nell'esempio seguente sono elencati tutti gli oggetti in 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());
    }
}

Nell'esempio seguente sono elencati gli oggetti con un determinato prefisso:

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

Per ulteriori informazioni, consulta API Cloud Storage Python documentazione di riferimento.

Per eseguire l'autenticazione su Cloud Storage, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale.

Nell'esempio seguente sono elencati tutti gli oggetti in 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)

Nell'esempio seguente sono elencati gli oggetti con un determinato prefisso:

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

Per ulteriori informazioni, consulta API Cloud Storage Ruby documentazione di riferimento.

Per eseguire l'autenticazione su Cloud Storage, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale.

Nell'esempio seguente sono elencati tutti gli oggetti in 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

Nell'esempio seguente sono elencati gli oggetti con un determinato prefisso:

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. Avere gcloud CLI installato e inizializzato, per generare un token di accesso per l'intestazione Authorization.

   In alternativa, puoi creare un token di accesso utilizzando il metodo OAuth 2.0 Playground e includilo nell'intestazione Authorization.

2. Utilizza cURL per chiamare l'API JSON con un richiedi di elencare gli oggetti:

   curl -X GET -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     "https://storage.googleapis.com/storage/v1/b/BUCKET_NAME/o"

   Dove BUCKET_NAME è il nome del bucket di cui vuoi elencare gli oggetti. Ad esempio, my-bucket.

   Puoi usare la query includeFoldersAsPrefixes=True per restituire le cartelle gestite nell'elenco che consentono di analizzare i dati e visualizzare i risultati. Quando utilizzi includeFoldersAsPrefixes , il parametro delimiter deve essere impostato su /.

   Per restituire gli ACL degli oggetti, aggiungi il parametro di query projection con il valore full alla tua richiesta. Tieni presente che gli ACL sono disabilitati e non può essere restituito se è impostato un accesso uniforme a livello di bucket siano abilitate sul bucket.

API XML

1. Avere gcloud CLI installato e inizializzato, per generare un token di accesso per l'intestazione Authorization.

   In alternativa, puoi creare un token di accesso utilizzando il metodo OAuth 2.0 Playground e includilo nell'intestazione Authorization.

2. Utilizza cURL per chiamare l'API XML con un Richiesta GET bucket:

   curl -X GET -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     "https://storage.googleapis.com/BUCKET_NAME?list-type=2"

   Dove BUCKET_NAME è il nome del bucket di cui vuoi elencare gli oggetti. Ad esempio, my-bucket.

   Puoi usare una stringa di query prefix=PREFIX per limitare i risultati agli oggetti che hanno il valore .

Applicazione di filtri agli oggetti

Console

Per filtrare gli oggetti in base al prefisso del nome utilizzando la console Google Cloud, utilizza il campo Filtra oggetti e cartelle della pagina Dettagli bucket.

Per ulteriori opzioni di filtro disponibili, consulta la sezione su filtri e ordinamento. utilizzando la console Google Cloud.

Riga di comando

Quando elenchi gli oggetti utilizzando Google Cloud CLI, puoi utilizzare caratteri jolly per filtrare gli oggetti che iniziano con un prefisso specificato o terminare con un suffisso specificato. Ad esempio, il seguente comando corrisponde oggetti che iniziano con image e terminano con .png:

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

Per ulteriori informazioni sull'applicazione di filtri utilizzando Google Cloud CLI, consulta Documentazione di gcloud storage ls.

API REST

API JSON

Quando elenchi gli oggetti utilizzando l'API JSON di Cloud Storage, puoi usa i parametri della stringa di query prefix o matchGlob per filtrare i risultati. Per maggiori dettagli sull'uso di questa stringa di query vedi i parametri Documentazione di riferimento dell'API JSON per l'elenco degli oggetti.

Filtro per prefisso

Puoi usare il parametro prefix=PREFIX o la stringa di query per limitare i risultati a oggetti o cartelle gestite con il prefisso specificato. Ad esempio, per elencare tutti gli oggetti nel bucket my-bucket con il prefisso folder/subfolder/, crea un elenco di oggetti utilizzando l'URL "https://storage.googleapis.com/storage/v1/b/my-bucket/o?prefix=folder/subfolder/".

L'utilizzo di prefix per elencare i contenuti di una cartella gestita è utile per quando hai solo l'autorizzazione per elencare gli oggetti nella ma non l'intero bucket. Ad esempio, supponi di avere IAM Visualizzatore oggetti Storage (roles/storage.objectViewer) per la cartella gestita my-bucket/my-managed-folder-a/, ma non per nella cartella gestita my-bucket/my-managed-folder-b/. Per restituire solo in my-managed-folder-a, puoi specificare prefix=my-managed-folder-a/.

Quando limiti i risultati a una cartella gestita e agli oggetti al suo interno, devi terminare PREFIX con / (ad esempio, prefix=my-managed-folder/). In caso contrario, i risultati possono includere anche adiacenti alla cartella gestita. In questo esempio, un bucket contiene i seguenti oggetti:

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

Se specifichi prefix=abc/ puoi restituire gli oggetti my-bucket/abc/object.txt, specificando prefix=abc può restituire sia my-bucket/abc.txt che my-bucket/abc/object.txt.

Filtro per espressione glob

Puoi usare la query matchGlob=GLOB_PATTERN per filtrare i risultati e visualizzare solo gli oggetti che corrispondono a un espressione glob specifica. Ad esempio, matchGlob=**.jpeg può da utilizzare per trovare corrispondenze con tutti gli oggetti che terminano con .jpeg.

Le richieste che utilizzano il parametro matchGlob non andranno a buon fine se includono anche un parametro delimiter impostato su un valore diverso da /.

Passaggi successivi

• Scarica un oggetto dal bucket.
• Visualizza e modifica i metadati degli oggetti.
• Elimina gli oggetti dal bucket.
• Scopri come suddividere in pagine i risultati.