Elenco degli oggetti

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

Prima di iniziare

Per ottenere le autorizzazioni necessarie per elencare gli oggetti, chiedi all'amministratore di concederti il ruolo IAM Visualizzatore oggetti archiviazione (roles/storage.objectViewer) per il bucket contenente gli oggetti che vuoi elencare.

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

Questi ruoli contengono le autorizzazioni necessarie per elencare gli oggetti. Per visualizzare le autorizzazioni esatte richieste, espandi la sezione Autorizzazioni richieste:

Autorizzazioni obbligatorie

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

Puoi anche ottenere queste autorizzazioni con altri ruoli predefiniti o 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 il flag --recursive:

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
...

Librerie client

C++

Per saperne di più, consulta la documentazione di riferimento dell'API Cloud Storage C++.

Per eseguire l'autenticazione su Cloud Storage, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare 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";
  }
}

L'esempio seguente elenca 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 autenticarti a Cloud Storage, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

L'esempio seguente elenca 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 autenticarti a Cloud Storage, configura le 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 saperne di più, consulta la documentazione di riferimento dell'API Cloud Storage Java.

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

L'esempio seguente elenca 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 saperne di più, consulta la documentazione di riferimento dell'API Cloud Storage Node.js.

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.

L'esempio seguente elenca 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);

L'esempio seguente elenca 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 autenticarti a Cloud Storage, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale.

L'esempio seguente elenca 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());
    }
}

L'esempio seguente elenca 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 autenticarti a Cloud Storage, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale.

L'esempio seguente elenca 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)

L'esempio seguente elenca 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 autenticarti a Cloud Storage, configura le 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, che consente generi un token di accesso per l'intestazione Authorization.

  2. Utilizza cURL per chiamare l'API JSON con una richiesta per 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 cuyos oggetti vuoi elencare. 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 /.

API XML

  1. Avere installato e inizializzato l'interfaccia a riga di comando gcloud, che consente di generare un token di accesso per l'intestazione Authorization.

  2. Utilizza cURLper chiamare l'API XML con una 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 .

Filtrare gli oggetti

Console

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

Consulta la sezione Filtro e ordinamento per ulteriori opzioni di filtro disponibili utilizzando la console Google Cloud.

Riga di comando

Quando elenchi gli oggetti utilizzando Google Cloud CLI, puoi utilizzare i caratteri jolly per filtrare gli oggetti che iniziano con un prefisso o terminano 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 la 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 bucketmy-bucket con il prefisso folder/subfolder/, effettua una richiesta di 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, hai un bucket che 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, mentre se specifichi prefix=abc puoi restituire sia my-bucket/abc.txt che my-bucket/abc/object.txt.

Filtrare per espressione glob

Puoi utilizzare il parametro della stringa di query matchGlob=GLOB_PATTERN per filtrare i risultati in modo da visualizzare solo gli oggetti che corrispondono a una 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 vanno a buon fine se includono anche un parametro delimiter impostato su un valore diverso da /.

Considerazioni sulle prestazioni per l'elenco degli oggetti

La struttura sottostante dei bucket con spazio dei nomi gerarchico abilitato può influire sul rendimento dell'operazione degli oggetti della scheda rispetto ai bucket con spazio dei nomi piatto. Per ulteriori informazioni su come ottimizzare le prestazioni quando si elencano gli oggetti nei bucket in cui è abilitato lo spazio dei nomi gerarchico, consulta Elenco degli oggetti.

Passaggi successivi