Questa pagina è stata tradotta dall'API Cloud Translation.

Utilizzare Autoclass

Questa pagina mostra come abilitare, disabilitare e controllare lo stato della funzionalità Autoclass, impostata su un bucket in Cloud Storage.

Ruoli obbligatori

Per ottenere le autorizzazioni necessarie per impostare e gestire Autoclass su un bucket, chiedi all'amministratore di concederti il ruolo IAM Amministratore Storage (roles/storage.admin) nel bucket. Questo ruolo predefinito contiene le autorizzazioni necessarie per impostare e gestire Autoclass in un bucket. Per visualizzare esattamente le autorizzazioni richieste, espandi la sezione Autorizzazioni obbligatorie:

Autorizzazioni obbligatorie

storage.buckets.get
storage.buckets.list
- Questa autorizzazione è richiesta solo per utilizzare la console Google Cloud allo scopo di eseguire le attività in questa pagina.
storage.buckets.update

Puoi ottenere queste autorizzazioni anche con i ruoli personalizzati.

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

Imposta Autoclass per un bucket

Per impostare Autoclass per un bucket, completa le seguenti istruzioni:

Console

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

Vai a Bucket
Nell'elenco dei bucket, fai clic sul nome del bucket che ti interessa.
Nella pagina Dettagli bucket, fai clic sulla scheda Configurazione.
Fai clic sull'icona Modifica () in corrispondenza di Classe di archiviazione predefinita.
Nella finestra dell'overlay, seleziona Autoclass per attivare Autoclass. Per disabilitare Autoclass, seleziona Imposta una classe predefinita, quindi seleziona una classe di archiviazione predefinita per il bucket.
Fai clic su Conferma.
Per cambiare la classe di archiviazione del terminale per un bucket in cui è abilitato Autoclass, fai clic sull'icona Modifica () per Classi incluse e fai clic su Conferma nella finestra dell'overlay visualizzata.

Riga di comando

Utilizza il comando gcloud storage buckets update con il flag appropriato:

gcloud storage buckets update gs://BUCKET_NAME FLAG

Dove:

BUCKET_NAME è il nome del bucket pertinente. Ad esempio, my-bucket.
FLAG corrisponde a uno dei seguenti:
- --enable-autoclass per abilitare Autoclass.
- --no-enable-autoclass per disabilitare Autoclass.
- --autoclass-terminal-storage-class=CLASS per impostare la classe di archiviazione del terminale per Autoclass. CLASS può essere NEARLINE o ARCHIVE.

Se l'esito è positivo, la risposta è simile al seguente esempio:

Updating gs://my-bucket/...
  Completed 1

Librerie client

C++

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

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

namespace gcs = ::google::cloud::storage;
[](gcs::Client client, std::string const& bucket_name, bool enabled) {
  auto metadata = client.PatchBucket(
      bucket_name, gcs::BucketMetadataPatchBuilder().SetAutoclass(
                       gcs::BucketAutoclass{enabled}));
  if (!metadata) throw google::cloud::Status(std::move(metadata).status());

  std::cout << "The autoclass configuration for bucket " << bucket_name
            << " was successfully updated.";
  if (!metadata->has_autoclass()) {
    std::cout << " The bucket no longer has an autoclass configuration.\n";
    return;
  }
  std::cout << " The new configuration is " << metadata->autoclass() << "\n";
}

C#

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


using Google.Cloud.Storage.V1;
using Google.Apis.Storage.v1.Data;
using static Google.Apis.Storage.v1.Data.Bucket;
using System;

public class SetAutoclassSample
{
    public Bucket SetAutoclass(string bucketName)
    {
        var storage = StorageClient.Create();
        var bucket = storage.GetBucket(bucketName);
        bucket.Autoclass = new AutoclassData { Enabled = true, TerminalStorageClass = "ARCHIVE" };
        storage.PatchBucket(bucket);
        Console.WriteLine($"Autoclass enabled is set to {bucket.Autoclass.Enabled} for {bucketName} at {bucket.Autoclass.ToggleTimeDateTimeOffset}.");
        Console.WriteLine($"Autoclass terminal storage class is {bucket.Autoclass.TerminalStorageClass}.");
        return bucket;
    }
}

Go

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

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

	"cloud.google.com/go/storage"
)

// setAutoclass sets the Autoclass configuration for a bucket.
func setAutoclass(w io.Writer, bucketName string) error {
	// bucketName := "bucket-name"

	// To update the configuration for Autoclass.TerminalStorageClass,
	// Autoclass.Enabled must also be set to true.
	// To disable autoclass on the bucket, set to an empty &Autoclass{}.
	enabled := true
	terminalStorageClass := "ARCHIVE"
	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()

	bucket := client.Bucket(bucketName)
	bucketAttrsToUpdate := storage.BucketAttrsToUpdate{
		Autoclass: &storage.Autoclass{
			Enabled:              enabled,
			TerminalStorageClass: terminalStorageClass,
		},
	}
	if _, err := bucket.Update(ctx, bucketAttrsToUpdate); err != nil {
		return fmt.Errorf("Bucket(%q).Update: %w", bucketName, err)
	}
	fmt.Fprintf(w, "Autoclass enabled was set to %v on bucket %q \n", bucketAttrsToUpdate.Autoclass.Enabled, bucketName)
	fmt.Fprintf(w, "Autoclass terminal storage class was last updated to %v at %v", bucketAttrsToUpdate.Autoclass.TerminalStorageClass, bucketAttrsToUpdate.Autoclass.TerminalStorageClassUpdateTime)
	return nil
}

Java

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


import com.google.cloud.storage.Bucket;
import com.google.cloud.storage.BucketInfo.Autoclass;
import com.google.cloud.storage.Storage;
import com.google.cloud.storage.Storage.BucketTargetOption;
import com.google.cloud.storage.StorageClass;
import com.google.cloud.storage.StorageOptions;

public class SetBucketAutoclass {
  public static void setBucketAutoclass(
      String projectId, String bucketName, StorageClass storageClass) throws Exception {
    // The ID of your GCP project
    // String projectId = "your-project-id";

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

    // The storage class that objects in an Autoclass bucket eventually transition to if not read
    // for a certain length of time
    // StorageClass storageClass = StorageClass.ARCHIVE;

    // Configure the Autoclass setting for a bucket.

    // Note:  terminal_storage_class field is optional and defaults to NEARLINE if not otherwise
    // specified. Valid terminal_storage_class values are NEARLINE and ARCHIVE.
    boolean enabled = true;

    try (Storage storage =
        StorageOptions.newBuilder().setProjectId(projectId).build().getService()) {
      Bucket bucket = storage.get(bucketName);

      Bucket toUpdate =
          bucket
              .toBuilder()
              .setAutoclass(
                  Autoclass.newBuilder()
                      .setEnabled(enabled)
                      .setTerminalStorageClass(storageClass)
                      .build())
              .build();

      Bucket updated = storage.update(toUpdate, BucketTargetOption.metagenerationMatch());

      System.out.println(
          "Autoclass for bucket "
              + bucketName
              + " was "
              + (updated.getAutoclass().getEnabled() ? "enabled." : "disabled."));
      System.out.println(
          "Autoclass terminal storage class is "
              + updated.getAutoclass().getTerminalStorageClass().toString());
    }
  }
}

Node.js

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

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

// The terminal storage class to be set on your GCS bucket. Valid values are NEARLINE and ARCHIVE.
// const terminalStorageClass = 'NEARLINE';

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

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

async function setAutoclass() {
  // Configure the Autoclass setting for a bucket.
  // terminalStorageClass field is optional and defaults to NEARLINE if not otherwise specified.
  // Valid terminalStorageClass values are NEARLINE and ARCHIVE.
  const [metadata] = await storage.bucket(bucketName).setMetadata({
    autoclass: {
      enabled: toggle,
      terminalStorageClass,
    },
  });

  console.log(
    `Autoclass terminal storage class is ${metadata.autoclass.terminalStorageClass}.`
  );
}

setAutoclass().catch(console.error);

PHP

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

use Google\Cloud\Storage\StorageClient;

/**
 * Updates an existing bucket with provided autoclass config.
 *
 * @param string $bucketName The name of your Cloud Storage bucket (e.g. 'my-bucket').
 * @param bool $autoclassStatus If true, enables Autoclass. Disables otherwise.
 * @param string $terminalStorageClass This field is optional and defaults to `NEARLINE`.
 *        Valid values are `NEARLINE` and `ARCHIVE`.
 */
function set_bucket_autoclass(
    string $bucketName,
    bool $autoclassStatus,
    string $terminalStorageClass
): void {
    $storage = new StorageClient();
    $bucket = $storage->bucket($bucketName);

    $bucket->update([
        'autoclass' => [
            'enabled' => $autoclassStatus,
            'terminalStorageClass' => $terminalStorageClass
        ],
    ]);

    $info = $bucket->info();
    printf(
        'Updated bucket %s with autoclass set to %s.' . PHP_EOL,
        $info['name'],
        $autoclassStatus ? 'true' : 'false'
    );
    printf(
        'Autoclass terminal storage class is %s.' . PHP_EOL,
        $info['autoclass']['terminalStorageClass']
    );
}

Python

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

from google.cloud import storage


def set_autoclass(bucket_name):
    """Configure the Autoclass setting for a bucket.

    terminal_storage_class field is optional and defaults to NEARLINE if not otherwise specified.
    Valid terminal_storage_class values are NEARLINE and ARCHIVE.
    """
    # The ID of your GCS bucket
    # bucket_name = "my-bucket"
    # Enable Autoclass for a bucket. Set enabled to false to disable Autoclass.
    # Set Autoclass.TerminalStorageClass, valid values are NEARLINE and ARCHIVE.
    enabled = True
    terminal_storage_class = "ARCHIVE"

    storage_client = storage.Client()
    bucket = storage_client.bucket(bucket_name)

    bucket.autoclass_enabled = enabled
    bucket.autoclass_terminal_storage_class = terminal_storage_class
    bucket.patch()
    print(f"Autoclass enabled is set to {bucket.autoclass_enabled} for {bucket.name} at {bucket.autoclass_toggle_time}.")
    print(f"Autoclass terminal storage class is {bucket.autoclass_terminal_storage_class}.")

    return bucket

Ruby

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

require "google/cloud/storage"

##
# This is a snippet for showcasing how to set the autoclass
# configuration of a bucket.
#
# @param bucket_name [String] The ID of your GCS bucket (e.g. "your-unique-bucket-name")
# @param toggle [Boolean] if true, enables Autoclass; if false, disables Autoclass
#
def set_autoclass bucket_name:, toggle:, terminal_storage_class: nil
  # Initialize client
  storage = Google::Cloud::Storage.new

  # Fetch the GCS bucket
  bucket = storage.bucket bucket_name

  # Update the autoclass configuration
  bucket.update_autoclass({ enabled: toggle, terminal_storage_class: terminal_storage_class })
  terminal_class_update_time = bucket.autoclass_terminal_storage_class_update_time

  # Get autoclass config of the bucket
  puts "Bucket #{bucket.name} has autoclass config set to #{bucket.autoclass_enabled}."
  puts "Bucket #{bucket.name} has autoclass toggle time set to #{bucket.autoclass_toggle_time}."
  puts "Bucket #{bucket.name} has autoclass terminal storage class set to #{bucket.autoclass_terminal_storage_class}."
  puts "Bucket #{bucket.name} has autoclass terminal storage class update time set to #{terminal_class_update_time}."
end

API REST

API JSON

Installa e inizializzato gcloud CLI per generare un token di accesso per l'intestazione Authorization.

In alternativa, puoi creare un token di accesso utilizzando OAuth 2.0 Playground e includerlo nell'intestazione Authorization.
Crea un file JSON contenente le seguenti informazioni:
```
{
  "storageClass": "DEFAULT_CLASS",
  "autoclass": {
    "enabled": BOOLEAN,
    "terminalStorageClass":TERMINAL_CLASS
  }
}
```
Dove:
- DEFAULT_CLASS imposta i metadati della classe di archiviazione per il bucket. Quando abiliti Autoclass, STANDARD è l'unico valore valido ed è obbligatorio se il bucket attualmente utilizza una classe di archiviazione diversa.
- BOOLEAN è true per abilitare Autoclass o false per disabilitare Autoclass.
- TERMINAL_CLASS è la classe di archiviazione del terminale da utilizzare quando Autoclass è abilitato.

Usa cURL per chiamare l'API JSON con una richiesta PATCH Bucket:

curl -X PATCH --data-binary @JSON_FILE_NAME \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json" \
"https://storage.googleapis.com/storage/v1/b/BUCKET_NAME?fields=autoclass"

Dove:

JSON_FILE_NAME è il percorso del file JSON creato al passaggio 2.
BUCKET_NAME è il nome del bucket pertinente. Ad esempio, my-bucket.

API XML

Questa funzionalità non può essere gestita tramite l'API XML. Utilizza la console Google Cloud o un altro strumento.

Visualizzare lo stato Autoclass di un bucket

Per visualizzare lo stato di Autoclass per un singolo bucket: