Mostrar objetos

En esta página se explica cómo enumerar los objetos almacenados en tus segmentos de Cloud Storage, que se ordenan en la lista lexicográficamente por nombre.

Antes de empezar

Para obtener los permisos que necesitas para enumerar objetos, pide a tu administrador que te conceda el rol de gestión de identidades y accesos Lector de objetos de Storage (roles/storage.objectViewer) en el segmento que contiene los objetos que quieres enumerar. Si quiere mostrar los objetos de las carpetas gestionadas, puede conceder el permiso roles/storage.objectViewer en la carpeta gestionada que contenga los objetos que quiera ver en lugar de en el contenedor.

Si tienes previsto usar la Google Cloud consola para realizar las tareas de esta página, pide a tu administrador que te conceda el rol básico Lector (roles/viewer) además del rol Visor de objetos de Storage (roles/storage.objectViewer).

Estos roles contienen los permisos necesarios para enumerar objetos. Para ver los permisos exactos que se necesitan, despliega la sección Permisos obligatorios:

Permisos obligatorios

  • storage.objects.list
  • storage.buckets.list
    • Este permiso solo es necesario si quieres usar la Google Cloud consola para realizar las tareas de esta página.

También puedes obtener estos permisos con otros roles predefinidos o roles personalizados.

Para obtener información sobre cómo conceder roles a los contenedores, consulta Usar IAM con contenedores.

Mostrar los objetos de un segmento

Consola

  1. En la Google Cloud consola, ve a la página Segmentos de Cloud Storage.

    Ir a Contenedores

  2. En la lista de segmentos, haga clic en el nombre del segmento cuyo contenido quiera ver.

Línea de comandos

Usa el comando gcloud storage ls:

gcloud storage ls gs://BUCKET_NAME

Donde:

  • BUCKET_NAME es el nombre del segmento que contiene los objetos que quieres enumerar. Por ejemplo, my-bucket.

Bibliotecas de cliente

C++

Para obtener más información, consulta la documentación de referencia de la API C++ de Cloud Storage.

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación para bibliotecas de cliente.

En el siguiente ejemplo se enumeran todos los objetos de un segmento:

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";
  }
}

En el siguiente ejemplo se enumeran los objetos con un prefijo determinado:

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#

Para obtener más información, consulta la documentación de referencia de la API C# de Cloud Storage.

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación para bibliotecas de cliente.

En el siguiente ejemplo se enumeran todos los objetos de un segmento:


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;
    }
}

En el siguiente ejemplo se enumeran los objetos con un prefijo determinado:


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

Para obtener más información, consulta la documentación de referencia de la API Go de Cloud Storage.

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación para bibliotecas de cliente.

En el siguiente ejemplo se enumeran todos los objetos de un segmento:

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
}

En el siguiente ejemplo se enumeran los objetos con un prefijo determinado:

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

Para obtener más información, consulta la documentación de referencia de la API Java de Cloud Storage.

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación para bibliotecas de cliente.

En el siguiente ejemplo se enumeran todos los objetos de un segmento:

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());
    }
  }
}

En el siguiente ejemplo se enumeran los objetos con un prefijo determinado:

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

Para obtener más información, consulta la documentación de referencia de la API Node.js de Cloud Storage.

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación para bibliotecas de cliente.

En el siguiente ejemplo se enumeran todos los objetos de un segmento:

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

En el siguiente ejemplo se enumeran los objetos con un prefijo determinado:

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

Para obtener más información, consulta la documentación de referencia de la API PHP de Cloud Storage.

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación para bibliotecas de cliente.

En el siguiente ejemplo se enumeran todos los objetos de un segmento:

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());
    }
}

En el siguiente ejemplo se enumeran los objetos con un prefijo determinado:

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

Para obtener más información, consulta la documentación de referencia de la API Python de Cloud Storage.

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación para bibliotecas de cliente.

En el siguiente ejemplo se enumeran todos los objetos de un segmento:

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)

En el siguiente ejemplo se enumeran los objetos con un prefijo determinado:

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/


    Note: If you only want to list prefixes a/b/ and don't want to iterate over
    blobs, you can do

    ```
    for page in blobs.pages:
        print(page.prefixes)
    ```
    """

    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

Para obtener más información, consulta la documentación de referencia de la API Ruby de Cloud Storage.

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación para bibliotecas de cliente.

En el siguiente ejemplo se enumeran todos los objetos de un segmento:

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

En el siguiente ejemplo se enumeran los objetos con un prefijo determinado:

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

APIs REST

API JSON

  1. Tener instalada e inicializadala CLI de gcloud, que te permite generar un token de acceso para el encabezado Authorization.

  2. Usa cURL para llamar a la API JSON con una solicitud para enumerar objetos:

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

    Donde BUCKET_NAME es el nombre del contenedor cuyos objetos quieres enumerar. Por ejemplo, my-bucket.

API XML

  1. Tener instalada e inicializadala CLI de gcloud, que te permite generar un token de acceso para el encabezado Authorization.

  2. Usa cURLpara llamar a la API XML con una solicitud de GET contenedor:

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

    Donde BUCKET_NAME es el nombre del contenedor cuyos objetos quieres enumerar. Por ejemplo, my-bucket.

    Puede usar un parámetro de cadena de consulta prefix=PREFIX para limitar los resultados a los objetos que tengan el prefijo especificado.

Mostrar los objetos de una carpeta

Consola

  1. En la Google Cloud consola, ve a la página Segmentos de Cloud Storage.

    Ir a Contenedores

  2. En la lista de segmentos, haz clic en el nombre del segmento que contiene la carpeta.

  3. En la pestaña Objetos de la página Detalles del segmento, haga clic en el nombre de la carpeta cuyo contenido quiera ver.

Línea de comandos

Usa el comando gcloud storage ls para enumerar los objetos de una carpeta:

gcloud storage ls gs://BUCKET_NAME/FOLDER_NAME

Donde:

  • BUCKET_NAME es el nombre del segmento que contiene la carpeta. Por ejemplo, my-bucket.

  • FOLDER_NAME es el nombre de la carpeta que contiene los objetos que quieres enumerar. Por ejemplo, my-folder.

APIs REST

API JSON

Para enumerar los objetos de una carpeta, usa una solicitud de lista de objetos con los parámetros prefix y delimiter. Cuando se configura el parámetro prefix, la operación de lista se limita a devolver solo los objetos y las carpetas que se encuentren en el prefijo. Cuando se define el parámetro delimiter, la lista prefixes[] de la respuesta se rellena con los nombres de las carpetas que tienen el prefijo especificado.

Por ejemplo:

  • Para enumerar todos los objetos de la carpeta image/ del contenedor my-bucket, usa la siguiente URL: "https://storage.googleapis.com/storage/v1/b/my-bucket/o?prefix=image&delimiter=/".

    Esto podría devolver los objetos my-bucket/image/cat.jpeg y my-bucket/image/dog.jpeg.

  • Para incluir objetos de subcarpetas en image/, elimina el parámetro delimiter: "https://storage.googleapis.com/storage/v1/b/my-bucket/o?prefix=image".

    Esto podría devolver los objetos my-bucket/image/cat.jpeg, my-bucket/image/dog.jpeg y my-bucket/image/dog/shiba.jpeg.

Para usar comodines en la solicitud de objetos de lista y buscar objetos por expresión glob, usa el parámetro matchGlob. Por ejemplo, matchGlob=**.jpeg coincide con todos los objetos que terminan en .jpeg. Cuando utilice matchGlob, debe asignar el valor / a delimiter.

Por ejemplo, usa la siguiente URL para que coincida con todos los objetos de la carpeta image que terminen en .jpeg: "https://storage.googleapis.com/storage/v1/b/my-bucket/o?prefix=image&delimiter=/&matchGlob=**.jpeg"

Para obtener más información sobre cómo usar parámetros para filtrar objetos, consulta la documentación de referencia de la API JSON de la lista de objetos.

Caso práctico

Usar prefix para mostrar el contenido de una carpeta puede ser útil cuando solo tienes permiso para mostrar objetos en la carpeta, pero no en todo el segmento. Por ejemplo, supongamos que tienes el rol de gestión de identidades y accesos Lector de objetos de Storage (roles/storage.objectViewer) para la carpeta gestionada my-bucket/my-managed-folder-a/, pero no para la carpeta gestionada my-bucket/my-managed-folder-b/. Para devolver solo los objetos de my-managed-folder-a, puedes especificar prefix=my-managed-folder-a/.

Filtrar objetos

Cuando se enumeran objetos, se pueden usar prefijos o sufijos en la solicitud de lista para filtrar los objetos por nombre.

Consola

Consulte la sección sobre filtrado y ordenación para obtener información sobre cómo filtrar y ordenar objetos en cubos o carpetas.

Línea de comandos

Puedes usar comodines en el comando gcloud storage ls para filtrar objetos por prefijo o sufijo. Por ejemplo, el siguiente comando solo muestra los objetos del contenedor my-bucket cuyo nombre empieza por image y termina por .png:

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

Si la solicitud se realiza correctamente, la respuesta será similar a la siguiente:

gs://my-bucket/image.png
gs://my-bucket/image-dog.png
gs://my-bucket/image-cat.png
...

Puedes usar comodines de doble asterisco para buscar coincidencias con cero o más niveles de carpetas en una ruta. Por ejemplo, el siguiente comando solo muestra los objetos cuyo nombre termina en .jpeg en cualquier carpeta o subcarpeta del segmento my-bucket:

gcloud storage ls gs://my-bucket/**/*.jpeg

Si la solicitud se realiza correctamente, la respuesta será similar a la siguiente:

gs://my-bucket/puppy.jpeg
gs://my-bucket/pug.jpeg
gs://my-bucket/pets/dog.jpeg
...

APIs REST

Consulta Mostrar los objetos de las carpetas para obtener información sobre cómo filtrar objetos por prefijo de nombre de carpeta u objeto.

Consideraciones sobre el rendimiento al enumerar objetos

La estructura subyacente de los segmentos con el espacio de nombres jerárquico habilitado influye en el rendimiento de la operación de enumeración de objetos en comparación con los segmentos de espacio de nombres plano. Para obtener más información, consulta el artículo Optimizar el rendimiento de los contenedores con el espacio de nombres jerárquico habilitado.

Siguientes pasos