Utilizzare Autoclass

Overview

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 in un bucket, chiedi all'amministratore di concederti il ruolo IAM Amministratore Storage (roles/storage.admin) per il bucket. Questo ruolo predefinito contiene le autorizzazioni necessarie per impostare e gestire Autoclass in un bucket. Per visualizzare le autorizzazioni esatte richieste, espandi la sezione Autorizzazioni richieste:

Autorizzazioni obbligatorie

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

Puoi ottenere queste autorizzazioni anche con i ruoli personalizzati.

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

Imposta Autoclass per un bucket

Per impostare Autoclass per un bucket, segui queste 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 () per 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 Autoclass è abilitato, fai clic sull'icona Modifica () in corrispondenza di Classi incluse, quindi 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 è uno dei seguenti:
- --enable-autoclass per attivare Autoclass.
- --no-enable-autoclass per disattivare Autoclass.
- --autoclass-terminal-storage-class=CLASS per impostare la classe di archiviazione del terminale per Autoclass. CLASS può essere NEARLINE o ARCHIVE.

In caso di esito positivo, la risposta sarà simile al seguente esempio:

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

Librerie client

C++

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

Per eseguire l'autenticazione in 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 maggiori 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 maggiori 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.
// See https://cloud.google.com/storage/docs/using-autoclass for more information.

// Note: Only update requests that disable Autoclass are currently supported.
// To enable Autoclass, you must set it at bucket creation time.
func setAutoclass(w io.Writer, bucketName string) error {
	// bucketName := "bucket-name"
	// Enable Autoclass for a bucket. Set enabled to false to disable Autoclass.
	// Set Autoclass.TerminalStorageClass, valid values are NEARLINE and ARCHIVE.
	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 maggiori 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 maggiori 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 maggiori 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 maggiori 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 maggiori 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

Assicurati che gcloud CLI sia installato e inizializzato 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 attivare Autoclass o false per disattivarlo.
- TERMINAL_CLASS è la classe di archiviazione del terminale da utilizzare quando Autoclass è abilitato.

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

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 nel 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: