Creare e gestire le cartelle gestite

Questo documento descrive come creare, elencare, ottenere, aggiornare ed eliminare le cartelle gestite.

Le cartelle gestite ti consentono di controllare l'accesso a gruppi di oggetti nei bucket Cloud Storage impostando in modo selettivo le policy IAM per gli oggetti che hanno un prefisso comune nei percorsi dei nomi degli oggetti. Questo approccio ti aiuta a soddisfare i requisiti di sicurezza e conformità dei dati.

Le cartelle gestite possono essere utilizzate anche per consentire alle cache Rapid Cache di inserire i dati in scrittura in modo selettivo in base al prefisso del nome dell'oggetto. Per ulteriori informazioni, vedi Ingest-on-write.

Prima di iniziare

Per creare e gestire cartelle gestite, devi prima abilitare l'accesso uniforme a livello di bucket e ottenere i ruoli IAM richiesti.

Abilita l'accesso uniforme a livello di bucket

Se non l'hai ancora fatto, abilita l'accesso uniforme a livello di bucket.

Ottenere i ruoli richiesti

Per ottenere le autorizzazioni necessarie per creare e gestire cartelle gestite, chiedi all'amministratore di concederti il ruolo IAM Storage Folder Admin (roles/storage.folderAdmin) sul bucket.

Questo ruolo predefinito contiene le autorizzazioni necessarie per creare e gestire le cartelle gestite. Per vedere quali sono esattamente le autorizzazioni richieste, espandi la sezione Autorizzazioni obbligatorie:

Autorizzazioni obbligatorie

Per creare e gestire cartelle gestite sono necessarie le seguenti autorizzazioni:

  • Per creare cartelle gestite: storage.managedFolders.create
  • Per convalidare le cartelle gestite appena create elencandole: storage.objects.list
  • Per elencare le cartelle gestite: storage.managedFolders.list
  • Per ottenere le cartelle gestite: storage.managedFolders.get
  • Per spostare le cartelle gestite:
    • storage.managedFolders.delete (nel bucket di origine)
    • storage.managedFolders.create (nel bucket di destinazione)
  • Per aggiornare le cartelle gestite: storage.managedFolders.update
  • Per eliminare le cartelle gestite: storage.managedFolders.delete

Per informazioni sulla concessione dei ruoli sui bucket, consulta Impostare e gestire le policy IAM sui bucket.

Crea una cartella gestita

Console

Quando utilizzi la console Google Cloud , crei cartelle gestite attivando la gestione su cartelle o cartelle simulate. I passaggi seguenti descrivono come creare una cartella o una cartella simulata e poi attivare la gestione delle cartelle:

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

    Vai a Bucket

  2. Nell'elenco dei bucket, fai clic sul nome del bucket in cui vuoi creare cartelle gestite.

  3. Nella pagina Dettagli bucket, fai clic su Crea cartella per creare una nuova cartella. Se la cartella che vuoi convertire in una cartella gestita esiste già, vai al passaggio che descrive come accedere al menu Altre opzioni .

  4. Nel campo Nome, inserisci un nome per la cartella. Per considerazioni sulla denominazione, vedi Nomi delle cartelle gestite.

  5. Fai clic su Crea.

    La cartella appena creata viene visualizzata nel riquadro Browser delle cartelle.

  6. Nel riquadro Browser delle cartelle, fai clic sul menu Altre opzioni accanto alla cartella che vuoi convertire in una cartella gestita e fai clic su accesso in modifica.

    Viene visualizzata la finestra di dialogo Abilitare la gestione delle cartelle?.

  7. Fai clic su Attiva.

    La cartella viene convertita in una cartella gestita. Viene visualizzato un riquadro Autorizzazioni per MANAGED_FOLDER_NAME che mostra i criteri IAM nella cartella per principal e ruolo. Per creare nuove policy IAM, consulta Impostare una policy IAM su una cartella gestita.

Riga di comando

Per creare una cartella gestita, esegui il comando gcloud storage managed-folders create:

gcloud storage managed-folders create gs://BUCKET_NAME/MANAGED_FOLDER_NAME

Dove:

  • BUCKET_NAME è il nome del bucket in cui vuoi creare una cartella gestita. Ad esempio, my-bucket.

  • MANAGED_FOLDER_NAME è il nome della cartella gestita che vuoi creare. Ad esempio, my-managed-folder/.

Per confermare la creazione della cartella gestita, esegui il comando gcloud storage managed-folders describe:

gcloud storage managed-folders describe gs://BUCKET_NAME/MANAGED_FOLDER_NAME

Dove:

  • BUCKET_NAME è il nome del bucket in cui hai creato una cartella gestita.

  • MANAGED_FOLDER_NAME è il nome della cartella gestita che hai creato.

Librerie client

C++

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

Per eseguire l'autenticazione in Cloud Storage, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client. 

namespace storagecontrol = google::cloud::storagecontrol_v2;
[](storagecontrol::StorageControlClient client,
   std::string const& bucket_name, std::string const& managed_folder_id) {
  auto const parent = std::string{"projects/_/buckets/"} + bucket_name;
  auto managed_folder = client.CreateManagedFolder(
      parent, google::storage::control::v2::ManagedFolder{},
      managed_folder_id);
  if (!managed_folder) throw std::move(managed_folder).status();

  std::cout << "Created managed folder: " << managed_folder->name() << "\n";
}

C#

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

Per eseguire l'autenticazione in Cloud Storage, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client. 

using Google.Cloud.Storage.Control.V2;
using System;

public class StorageControlCreateManagedFolderSample
{
    public ManagedFolder StorageControlCreateManagedFolder(string bucketId = "your-unique-bucket-name",
        string managedFolderId = "your_managed_folder_id")
    {
        StorageControlClient storageControl = StorageControlClient.Create();

        ManagedFolder managedFolder = storageControl.CreateManagedFolder(
            // Set project to "_" to signify globally scoped bucket
            new BucketName("_", bucketId),
            new ManagedFolder(),
            managedFolderId
        );

        Console.WriteLine($"Managed Folder {managedFolderId} created in bucket {bucketId}");
        return managedFolder;
    }
}

Go

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

Per eseguire l'autenticazione in Cloud Storage, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client. 

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

	control "cloud.google.com/go/storage/control/apiv2"
	"cloud.google.com/go/storage/control/apiv2/controlpb"
)

// createManagedFolder creates a managed folder in the bucket with the given name.
func createManagedFolder(w io.Writer, bucket, folder string) error {
	// bucket := "bucket-name"
	// folder := "managed-folder-name"

	ctx := context.Background()
	client, err := control.NewStorageControlClient(ctx)
	if err != nil {
		return fmt.Errorf("NewStorageControlClient: %w", err)
	}
	defer client.Close()

	ctx, cancel := context.WithTimeout(ctx, time.Second*30)
	defer cancel()
	mf := &controlpb.ManagedFolder{}

	req := &controlpb.CreateManagedFolderRequest{
		Parent:          fmt.Sprintf("projects/_/buckets/%v", bucket),
		ManagedFolder:   mf,
		ManagedFolderId: folder,
	}
	f, err := client.CreateManagedFolder(ctx, req)
	if err != nil {
		return fmt.Errorf("CreateManagedFolder(%q): %w", folder, err)
	}

	fmt.Fprintf(w, "created Managed Folder with path %q", f.Name)
	return nil
}

Java

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

Per eseguire l'autenticazione in Cloud Storage, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client. 


import com.google.storage.control.v2.BucketName;
import com.google.storage.control.v2.CreateManagedFolderRequest;
import com.google.storage.control.v2.ManagedFolder;
import com.google.storage.control.v2.StorageControlClient;

public class CreateManagedFolder {
  public static void managedFolderCreate(String bucketName, String managedFolderId)
      throws Exception {

    // Instantiates a client in a try-with-resource to automatically cleanup underlying resources
    try (StorageControlClient storageControlClient = StorageControlClient.create()) {
      CreateManagedFolderRequest request =
          CreateManagedFolderRequest.newBuilder()
              // Set project to "_" to signify global bucket
              .setParent(BucketName.format("_", bucketName))
              .setManagedFolder(ManagedFolder.newBuilder().build())
              .setManagedFolderId(managedFolderId)
              .build();
      String response = storageControlClient.createManagedFolder(request).getName();
      System.out.printf("Performed createManagedFolder request for %s%n", response);
    }
  }
}

Node.js

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

Per eseguire l'autenticazione in Cloud Storage, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client. 

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */

// The name of your GCS bucket
// const bucketName = 'bucketName';

// The name of the managed folder to be created
// const managedFolderName = 'managedFolderName';

// Imports the Control library
const {StorageControlClient} = require('@google-cloud/storage-control').v2;

// Instantiates a client
const controlClient = new StorageControlClient();

async function callCreateManagedFolder() {
  const bucketPath = controlClient.bucketPath('_', bucketName);

  // Create the request
  const request = {
    parent: bucketPath,
    managedFolderId: managedFolderName,
  };

  // Run request
  const [response] = await controlClient.createManagedFolder(request);
  console.log(`Created managed folder: ${response.name}.`);
}

callCreateManagedFolder();

PHP

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

Per eseguire l'autenticazione in Cloud Storage, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client. 

use Google\Cloud\Storage\Control\V2\Client\StorageControlClient;
use Google\Cloud\Storage\Control\V2\CreateManagedFolderRequest;
use Google\Cloud\Storage\Control\V2\ManagedFolder;

/**
 * Create a new folder in an existing bucket.
 *
 * @param string $bucketName The name of your Cloud Storage bucket.
 *        (e.g. 'my-bucket')
 * @param string $managedFolderId The name of your folder inside the bucket.
 *        (e.g. 'my-folder')
 */
function managed_folder_create(string $bucketName, string $managedFolderId): void
{
    $storageControlClient = new StorageControlClient();

    // Set project to "_" to signify global bucket
    $formattedName = $storageControlClient->bucketName('_', $bucketName);

    // $request = new CreateManagedFolderRequest([
    //     'parent' => $formattedName,
    //     'managedFolder' => new ManagedFolder(),
    //     'managedFolderId' => $managedFolderId,
    // ]);
    $request = CreateManagedFolderRequest::build($formattedName, new ManagedFolder(), $managedFolderId);

    $managedFolder = $storageControlClient->createManagedFolder($request);

    printf('Performed createManagedFolder request for %s', $managedFolder->getName());
}

Python

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

Per eseguire l'autenticazione in Cloud Storage, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client. 

from google.cloud import storage_control_v2


def create_managed_folder(bucket_name: str, managed_folder_id: str) -> None:
    # The ID of your GCS bucket
    # bucket_name = "your-unique-bucket-name"

    # The name of the managed folder to be created
    # managed_folder_id = "managed-folder-name"

    storage_control_client = storage_control_v2.StorageControlClient()
    # The storage bucket path uses the global access pattern, in which the "_"
    # denotes this bucket exists in the global namespace.
    project_path = storage_control_client.common_project_path("_")
    bucket_path = f"{project_path}/buckets/{bucket_name}"

    request = storage_control_v2.CreateManagedFolderRequest(
        parent=bucket_path,
        managed_folder_id=managed_folder_id,
    )
    response = storage_control_client.create_managed_folder(request=request)

    print(f"Created managed folder: {response.name}")

Ruby

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

Per eseguire l'autenticazione in Cloud Storage, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client. 

def create_managed_folder bucket_name:, managed_folder_id:
  # The ID of your GCS bucket
  # bucket_name = "your-unique-bucket-name"

  # The name of the managed folder to be created
  # managed_folder_id = "managed-folder-name"

  require "google/cloud/storage/control"

  storage_control = Google::Cloud::Storage::Control.storage_control

  # The storage bucket path uses the global access pattern, in which the "_"
  # denotes this bucket exists in the global namespace.
  bucket_path = storage_control.bucket_path project: "_", bucket: bucket_name

  request = Google::Cloud::Storage::Control::V2::CreateManagedFolderRequest.new parent: bucket_path,
                                                                                managed_folder_id: managed_folder_id

  response = storage_control.create_managed_folder request

  puts "Created managed folder: #{response.name}"
end

Rust

use google_cloud_storage::{client::StorageControl, model::ManagedFolder};

pub async fn sample(client: &StorageControl, bucket_id: &str) -> anyhow::Result<()> {
    const ID: &str = "example001";
    let folder = client
        .create_managed_folder()
        .set_parent(format!("projects/_/buckets/{bucket_id}"))
        .set_managed_folder_id(ID)
        .set_managed_folder(ManagedFolder::new())
        .send()
        .await?;
    println!("folder successfully created {folder:?}");
    Ok(())
}

API REST

API JSON

  1. Avere gcloud CLI installata e inizializzata, il che ti consente di generare un token di accesso per l'intestazione Authorization.

  2. Utilizza cURL per chiamare l'API JSON con una richiesta POST ManagedFolder:

    curl -X POST -H "Authorization: Bearer $(gcloud auth print-access-token)" \
-d '{ "name": "MANAGED_FOLDER_NAME" }' \
  "https://storage./storage/v1/b/BUCKET_NAME/managedFolders"

    Dove:

    • MANAGED_FOLDER_NAME è il nome della cartella gestita che vuoi creare. Ad esempio, my-managed-folder/.

    • BUCKET_NAME è il nome del bucket in cui vuoi creare una cartella gestita. Ad esempio, my-bucket.

    Crea una cartella gestita per abilitare l'inserimento in scrittura di Rapid Cache

    Questa sezione descrive come creare una cartella gestita con impostazioni che abilitano la funzionalità di importazione in scrittura della cache rapida a livello di prefisso. Se non utilizzi Rapid Cache o la relativa funzionalità di inserimento durante la scrittura, salta questa sezione.

    Se vuoi creare una cartella gestita per attivare l'inserimento a livello di prefisso in scrittura per le cache create con Rapid Cache:

    1. Leggi Informazioni sull'attivazione dell'importazione in scrittura per familiarizzare con la configurazione dell'importazione in scrittura a livello di prefisso.

    2. Assicurati che la proprietà ingestOnWrite della cache sia impostata su false. Per istruzioni, vedi Aggiornare una cache.

    3. Includi una configurazione rapidCacheConfig nella richiesta:

    curl -X POST -H "Authorization: Bearer $(gcloud auth print-access-token)" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "MANAGED_FOLDER_NAME",
    "rapidCacheConfig": {
      "policies": {
        "RAPID_CACHE_ID": {
          "rapidCacheId": "RAPID_CACHE_ID",
          "ingestOnWrite": "enabled"
        }
      }
    }
  }' \
  "https://storage./storage/v1/b/BUCKET_NAME/managedFolders"

    Dove:

    • MANAGED_FOLDER_NAME è il nome della cartella gestita che vuoi creare. La cache utilizza questo nome di cartella gestita per inserire selettivamente gli oggetti durante la scrittura. Ad esempio, se specifichi my-managed-folder/ come nome della cartella gestita, la cache inserirà solo gli oggetti nel bucket il cui nome include my-managed-folder/ nel percorso.

    • RAPID_CACHE_ID è l'identificatore della cache, ovvero la zona della cache. Ad esempio, us-east1-b. La cache specificata deve essere associata al bucket in cui viene creata la cartella gestita. Per trovare le cache associate a un bucket, elenca le cache per il bucket.

    • BUCKET_NAME è il nome del bucket associato alla cache. Ad esempio, my-cached-bucket. La cartella gestita verrà creata in questo bucket.

Elenca le cartelle gestite

Console

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

    Vai a Bucket

  2. Nel riquadro Browser delle cartelle, utilizza il nodo di attivazione/disattivazione per espandere l'elenco delle cartelle all'interno del bucket.

Un elenco mostra le cartelle, le cartelle simulate e le cartelle gestite nel bucket.

Riga di comando

Per elencare le cartelle gestite, esegui il comando gcloud storage managed-folders list:

gcloud storage managed-folders list gs://BUCKET_NAME

Dove:

  • BUCKET_NAME è il nome del bucket che contiene le cartelle gestite che vuoi elencare. Ad esempio, my-bucket.

Tieni presente che puoi anche specificare un percorso di cartella anziché un nome di bucket. Ad esempio:

gcloud storage managed-folders list gs://my-bucket/folder/

Librerie client

C++

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

Per eseguire l'autenticazione in Cloud Storage, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client. 

namespace storagecontrol = google::cloud::storagecontrol_v2;
[](storagecontrol::StorageControlClient client,
   std::string const& bucket_name) {
  auto const parent = std::string{"projects/_/buckets/"} + bucket_name;
  for (auto managed_folder : client.ListManagedFolders(parent)) {
    if (!managed_folder) throw std::move(managed_folder).status();
    std::cout << managed_folder->name() << "\n";
  }

  std::cout << bucket_name << std::endl;
}

C#

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

Per eseguire l'autenticazione in Cloud Storage, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client. 

using Google.Cloud.Storage.Control.V2;
using System;
using System.Collections.Generic;

public class StorageControlListManagedFoldersSample
{
    public IEnumerable<ManagedFolder> StorageControlListManagedFolders(string bucketId = "your-unique-bucket-name")
    {
        StorageControlClient storageControl = StorageControlClient.Create();

        // Use "_" for project ID to signify globally scoped bucket
        BucketName bucketResourceName = new BucketName("_", bucketId);
        var managedFolders = storageControl.ListManagedFolders(bucketResourceName);

        foreach (var managedFolder in managedFolders)
        {
            Console.Write(managedFolder.Name);
        }
        return managedFolders;
    }
}

Go

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

Per eseguire l'autenticazione in Cloud Storage, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client. 

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

	control "cloud.google.com/go/storage/control/apiv2"
	"cloud.google.com/go/storage/control/apiv2/controlpb"
	"google.golang.org/api/iterator"
)

// listManagedFolders lists all managed folders present in the bucket.
func listManagedFolders(w io.Writer, bucket string) error {
	// bucket := "bucket-name"
	// folder := "managed-folder-name"

	ctx := context.Background()
	client, err := control.NewStorageControlClient(ctx)
	if err != nil {
		return fmt.Errorf("NewStorageControlClient: %w", err)
	}
	defer client.Close()

	ctx, cancel := context.WithTimeout(ctx, time.Second*30)
	defer cancel()

	// Construct bucket path for a bucket containing folders.
	bucketPath := fmt.Sprintf("projects/_/buckets/%v", bucket)

	// List all folders present.
	req := &controlpb.ListManagedFoldersRequest{
		Parent: bucketPath,
	}
	it := client.ListManagedFolders(ctx, req)
	for {
		f, err := it.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			return fmt.Errorf("ListManagedFolders(%q): %w", bucketPath, err)
		}
		fmt.Fprintf(w, "got managed folder %v\n", f.Name)
	}

	return nil
}

Java

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

Per eseguire l'autenticazione in Cloud Storage, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client. 


import com.google.storage.control.v2.BucketName;
import com.google.storage.control.v2.ListManagedFoldersRequest;
import com.google.storage.control.v2.ManagedFolder;
import com.google.storage.control.v2.StorageControlClient;

class ListManagedFolders {

  public static void managedFolderList(String bucketName) throws Exception {
    // Instantiates a client in a try-with-resource to automatically cleanup underlying resources
    try (StorageControlClient storageControlClient = StorageControlClient.create()) {
      ListManagedFoldersRequest listManagedFoldersRequest =
          ListManagedFoldersRequest.newBuilder()
              // Set project to "_" to signify global bucket
              .setParent(BucketName.format("_", bucketName))
              .build();
      Iterable<ManagedFolder> managedFolders =
          storageControlClient.listManagedFolders(listManagedFoldersRequest).iterateAll();
      for (ManagedFolder folder : managedFolders) {
        System.out.printf("%s bucket has managed folder %s%n", bucketName, folder.getName());
      }
    }
  }
}

Node.js

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

Per eseguire l'autenticazione in Cloud Storage, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client. 

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */

// The name of your GCS bucket
// const bucketName = 'bucketName';

// Imports the Control library
const {StorageControlClient} = require('@google-cloud/storage-control').v2;

// Instantiates a client
const controlClient = new StorageControlClient();

async function callListManagedFolders() {
  const bucketPath = controlClient.bucketPath('_', bucketName);

  // Create the request
  const request = {
    parent: bucketPath,
  };

  // Run request
  const [folders] = await controlClient.listManagedFolders(request);
  for (const curManagedFolder of folders) {
    console.log(curManagedFolder.name);
  }
}

callListManagedFolders();

PHP

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

Per eseguire l'autenticazione in Cloud Storage, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client. 

use Google\Cloud\Storage\Control\V2\Client\StorageControlClient;
use Google\Cloud\Storage\Control\V2\ListManagedFoldersRequest;

/**
 * List folders in an existing bucket.
 *
 * @param string $bucketName The name of your Cloud Storage bucket.
 *        (e.g. 'my-bucket')
 */
function managed_folders_list(string $bucketName): void
{
    $storageControlClient = new StorageControlClient();

    // Set project to "_" to signify global bucket
    $formattedName = $storageControlClient->bucketName('_', $bucketName);

    $request = new ListManagedFoldersRequest([
        'parent' => $formattedName,
    ]);

    $folders = $storageControlClient->listManagedFolders($request);

    foreach ($folders as $folder) {
        printf('%s bucket has managed folder %s' . PHP_EOL, $bucketName, $folder->getName());
    }
}

Python

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

Per eseguire l'autenticazione in Cloud Storage, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client. 

from google.cloud import storage_control_v2


def list_managed_folders(bucket_name: str = "your-bucket-name") -> None:
    """Lists all managed folders in a Google Cloud Storage bucket.

    Args:
        bucket_name: The name of the Google Cloud Storage bucket.

    Returns:
        None. The function prints the name of each managed folder to the
        console.

    Example:
        >>> list_managed_folders(bucket_name="my-test-bucket")
        Managed folders in bucket projects/_/buckets/my-test-bucket:
            projects/_/buckets/my-test-bucket/managedFolders/folder-one
            projects/_/buckets/my-test-bucket/managedFolders/folder-two
    """
    client = storage_control_v2.StorageControlClient()

    # The storage bucket path uses the global access pattern,
    # in which the "_" denotes this bucket exists in the global namespace.
    GLOBAL_NAMESPACE_PATTERN = "_"
    bucket_resource_name = (
        f"projects/{GLOBAL_NAMESPACE_PATTERN}/buckets/{bucket_name}"
    )

    managed_folders = client.list_managed_folders(parent=bucket_resource_name)

    print(f"Managed folders in bucket {bucket_resource_name}:")
    for managed_folder in managed_folders:
        print(f"\t{managed_folder.name}")

Ruby

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

Per eseguire l'autenticazione in Cloud Storage, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client. 

def list_managed_folders bucket_name:
  # The ID of your GCS bucket
  # bucket_name = "your-unique-bucket-name"

  require "google/cloud/storage/control"

  storage_control = Google::Cloud::Storage::Control.storage_control

  # The storage bucket path uses the global access pattern, in which the "_"
  # denotes this bucket exists in the global namespace.
  bucket_path = storage_control.bucket_path project: "_", bucket: bucket_name

  request = Google::Cloud::Storage::Control::V2::ListManagedFoldersRequest.new parent: bucket_path

  managed_folders = storage_control.list_managed_folders request
  managed_folders.each do |managed_folder|
    puts managed_folder
  end

  puts "Listed managed folders in bucket #{bucket_name}"
end

Rust

use google_cloud_gax::paginator::ItemPaginator;
use google_cloud_storage::client::StorageControl;

pub async fn sample(client: &StorageControl, bucket_id: &str) -> anyhow::Result<()> {
    let mut items = client
        .list_managed_folders()
        .set_parent(format!("projects/_/buckets/{bucket_id}"))
        .by_item();
    println!("Listing managed folders in bucket {bucket_id}");
    while let Some(folder) = items.next().await.transpose()? {
        println!("{folder:?}");
    }
    println!("DONE");
    Ok(())
}

API REST

API JSON

  1. Avere gcloud CLI installata e inizializzata, il che ti consente di generare un token di accesso per l'intestazione Authorization.

  2. Utilizza cURL per chiamare l'API JSON con una richiesta di elencare le cartelle gestite:

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

    dove BUCKET_NAME è il nome del bucket che contiene le cartelle gestite che vuoi elencare. Ad esempio, my-bucket.

Recuperare i metadati di una cartella gestita

Riga di comando

Per ottenere i metadati di una cartella gestita, esegui il comando gcloud storage managed-folders describe:

  gcloud storage managed-folders describe gs://BUCKET_NAME/MANAGED_FOLDER_NAME

Dove:

  • BUCKET_NAME è il nome del bucket che contiene le cartelle gestite che vuoi elencare. Ad esempio, my-bucket.

  • MANAGED_FOLDER_NAME è il nome della cartella gestita per cui vuoi recuperare i metadati.

Librerie client

C++

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

Per eseguire l'autenticazione in Cloud Storage, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client. 

namespace storagecontrol = google::cloud::storagecontrol_v2;
[](storagecontrol::StorageControlClient client,
   std::string const& bucket_name, std::string const& managed_folder_id) {
  auto const name = std::string{"projects/_/buckets/"} + bucket_name +
                    "/managedFolders/" + managed_folder_id;
  auto managed_folder = client.GetManagedFolder(name);
  if (!managed_folder) throw std::move(managed_folder).status();

  std::cout << "Got managed folder: " << managed_folder->name() << "\n";
}

C#

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

Per eseguire l'autenticazione in Cloud Storage, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client. 

using Google.Cloud.Storage.Control.V2;
using System;

public class StorageControlGetManagedFolderSample
{
    public ManagedFolder StorageControlGetManagedFolder(string bucketId = "your-unique-bucket-name",
        string managedFolderId = "your_managed_folder_Id")
    {
        StorageControlClient storageControl = StorageControlClient.Create();

        ManagedFolderName managedFolderResourceName =
            // Set project to "_" to signify globally scoped bucket
            new ManagedFolderName("_", bucketId, managedFolderId);

        ManagedFolder managedFolder = storageControl.GetManagedFolder(managedFolderResourceName);

        Console.WriteLine($"Got managed folder: {managedFolder.Name}");
        return managedFolder;
    }
}

Go

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

Per eseguire l'autenticazione in Cloud Storage, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client. 

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

	control "cloud.google.com/go/storage/control/apiv2"
	"cloud.google.com/go/storage/control/apiv2/controlpb"
)

// getManagedFolder gets metadata for the managed folder with the given name.
func getManagedFolder(w io.Writer, bucket, folder string) error {
	// bucket := "bucket-name"
	// folder := "managed-folder-name"

	ctx := context.Background()
	client, err := control.NewStorageControlClient(ctx)
	if err != nil {
		return fmt.Errorf("NewStorageControlClient: %w", err)
	}
	defer client.Close()

	ctx, cancel := context.WithTimeout(ctx, time.Second*30)
	defer cancel()

	// Construct folder path including the bucket name.
	folderPath := fmt.Sprintf("projects/_/buckets/%v/managedFolders/%v/", bucket, folder)

	req := &controlpb.GetManagedFolderRequest{
		Name: folderPath,
	}
	f, err := client.GetManagedFolder(ctx, req)
	if err != nil {
		return fmt.Errorf("GetManagedFolder(%q): %w", folderPath, err)
	}

	fmt.Fprintf(w, "got managed folder metadata: %+v", f)
	return nil
}

Java

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

Per eseguire l'autenticazione in Cloud Storage, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client. 


import com.google.storage.control.v2.BucketName;
import com.google.storage.control.v2.GetManagedFolderRequest;
import com.google.storage.control.v2.ManagedFolder;
import com.google.storage.control.v2.ManagedFolderName;
import com.google.storage.control.v2.StorageControlClient;

class GetManagedFolder {

  public static void managedFolderGet(String bucketName, String managedFolderId) throws Exception {
    // Instantiates a client in a try-with-resource to automatically cleanup underlying resources
    try (StorageControlClient storageControlClient = StorageControlClient.create()) {
      // Set project to "_" to signify global bucket
      BucketName resourceBucketName = BucketName.of("_", bucketName);
      GetManagedFolderRequest getManagedFolderRequest =
          GetManagedFolderRequest.newBuilder()
              .setName(
                  ManagedFolderName.format(
                      resourceBucketName.getProject(),
                      resourceBucketName.getBucket(),
                      managedFolderId))
              .build();
      ManagedFolder managedFolder = storageControlClient.getManagedFolder(getManagedFolderRequest);
      System.out.printf("Got Managed Folder %s%n", managedFolder.getName());
    }
  }
}

Node.js

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

Per eseguire l'autenticazione in Cloud Storage, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client. 

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */

// The name of your GCS bucket
// const bucketName = 'bucketName';

// The name of the managed folder to get
// const managedFolderName = 'managedFolderName';

// Imports the Control library
const {StorageControlClient} = require('@google-cloud/storage-control').v2;

// Instantiates a client
const controlClient = new StorageControlClient();

async function callGetManagedFolder() {
  const managedFolderPath = controlClient.managedFolderPath(
    '_',
    bucketName,
    managedFolderName
  );

  // Create the request
  const request = {
    name: managedFolderPath,
  };

  // Run request
  const [response] = await controlClient.getManagedFolder(request);
  console.log(`Got managed folder: ${response.name}.`);
}

callGetManagedFolder();

PHP

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

Per eseguire l'autenticazione in Cloud Storage, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client. 

use Google\Cloud\Storage\Control\V2\Client\StorageControlClient;
use Google\Cloud\Storage\Control\V2\GetManagedFolderRequest;

/**
 * Get a folder in an existing bucket.
 *
 * @param string $bucketName The name of your Cloud Storage bucket.
 *        (e.g. 'my-bucket')
 * @param string $managedFolderId The name of your folder inside the bucket.
 *        (e.g. 'my-folder')
 */
function managed_folder_get(string $bucketName, string $managedFolderId): void
{
    $storageControlClient = new StorageControlClient();

    // Set project to "_" to signify global bucket
    $formattedName = $storageControlClient->managedFolderName('_', $bucketName, $managedFolderId);

    $request = new GetManagedFolderRequest([
        'name' => $formattedName,
    ]);

    $managedFolder = $storageControlClient->getManagedFolder($request);

    printf('Got Managed Folder %s', $managedFolder->getName());
}

Python

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

Per eseguire l'autenticazione in Cloud Storage, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client. 

from google.cloud import storage_control_v2


def get_managed_folder(bucket_name: str, managed_folder_id: str) -> None:
    # The ID of your GCS bucket
    # bucket_name = "your-unique-bucket-name"

    # The name of the managed folder
    # managed_folder_id = "managed-folder-name"

    storage_control_client = storage_control_v2.StorageControlClient()
    # The storage bucket path uses the global access pattern, in which the "_"
    # denotes this bucket exists in the global namespace.
    folder_path = storage_control_client.managed_folder_path(
        "_", bucket_name, managed_folder_id
    )

    request = storage_control_v2.GetManagedFolderRequest(
        name=folder_path,
    )
    response = storage_control_client.get_managed_folder(request=request)

    print(f"Got managed folder: {response.name}")

Ruby

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

Per eseguire l'autenticazione in Cloud Storage, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client. 

def get_managed_folder bucket_name:, managed_folder_id:
  # The ID of your GCS bucket
  # bucket_name = "your-unique-bucket-name"

  # The name of the managed folder to be created
  # managed_folder_id = "managed-folder-name"

  require "google/cloud/storage/control"

  storage_control = Google::Cloud::Storage::Control.storage_control

  # The storage bucket path uses the global access pattern, in which the "_"
  # denotes this bucket exists in the global namespace.
  folder_path = storage_control.managed_folder_path project: "_",
                                                    bucket: bucket_name,
                                                    managed_folder: managed_folder_id

  request = Google::Cloud::Storage::Control::V2::GetManagedFolderRequest.new name: folder_path

  response = storage_control.get_managed_folder request

  puts "Got managed folder: #{response.name}"
end

Rust

use google_cloud_storage::client::StorageControl;

pub async fn sample(client: &StorageControl, bucket_id: &str) -> anyhow::Result<()> {
    const ID: &str = "example001";
    let folder = client
        .get_managed_folder()
        .set_name(format!(
            "projects/_/buckets/{bucket_id}/managedFolders/{ID}"
        ))
        .send()
        .await?;
    println!("successfully retrieved managed folder metadata: {folder:?}");
    Ok(())
}

API REST

API JSON

  1. Avere gcloud CLI installata e inizializzata, il che ti consente di generare un token di accesso per l'intestazione Authorization.

  2. Utilizza cURL per chiamare l'API JSON con una richiesta per ottenere le cartelle gestite:

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

    Dove:

    • BUCKET_NAME è il nome del bucket che contiene le cartelle gestite che vuoi recuperare. Ad esempio, my-bucket.

    • MANAGED_FOLDER_NAME è il nome della cartella gestita espresso come percorso. Ad esempio, example-dir/. Se la cartella gestita è nidificata, il carattere barra (/) nel percorso della cartella gestita deve essere sottoposto a escape. Ad esempio, example-dir1%2Fexample-dir2.

Spostare una cartella gestita

Console

  1. Crea una nuova cartella gestita nel bucket di destinazione.

  2. Copia i criteri IAM dalla cartella gestita originale nel bucket di origine nella nuova cartella gestita nel bucket di destinazione.

  3. Copia gli oggetti dalla cartella gestita originale nel bucket di origine alla nuova cartella gestita nel bucket di destinazione.

  4. Elimina la cartella gestita originale dal bucket di origine.

Riga di comando

Per spostare le cartelle gestite e gli oggetti che contengono, esegui il comando gcloud storage mv con l'opzione --include-managed-folders:

gcloud storage mv --include-managed-folders gs://SOURCE_BUCKET_NAME/MANAGED_FOLDER_NAME gs://DESTINATION_BUCKET_NAME/MANAGED_FOLDER_NAME

Dove:

  • SOURCE_BUCKET è il nome del bucket originale. Ad esempio, my-source-bucket`.

  • DESTINATION_BUCKET è il nome del bucket in cui stai spostando la cartella gestita. Ad esempio, my-destination-bucket.

  • MANAGED_FOLDER_NAME è il nome della cartella gestita che stai spostando. Ad esempio, my-managed-folder/.

API REST

API JSON

Per spostare le cartelle gestite da un bucket all'altro, completa i seguenti passaggi:

  1. Crea una nuova cartella gestita nel bucket di destinazione.

  2. Copia le policy IAM dalla cartella gestita originale nel bucket di origine alla nuova cartella gestita nel bucket di destinazione.

  3. Copia gli oggetti dalla cartella gestita originale nel bucket di origine alla nuova cartella gestita nel bucket di destinazione.

  4. Elimina la cartella gestita originale dal bucket di origine.

Aggiorna il criterio di inserimento in scrittura della Rapid Cache in una cartella gestita

Questa sezione descrive come attivare o disattivare l'impostazione di inserimento in scrittura della cache rapida a livello di prefisso, che utilizza le cartelle gestite come meccanismo sottostante. Se non utilizzi Rapid Cache o la relativa funzionalità di inserimento durante la scrittura, salta questa sezione.

Per attivare o disattivare il criterio di inserimento in scrittura di Rapid Cache per gli oggetti che condividono un prefisso di cartella gestita, devi aggiornare la configurazione rapidCacheConfig della cartella gestita. Queste istruzioni sono necessarie solo quando utilizzi l'API JSON per aggiornare un criterio di inserimento in scrittura della cache.

Per ulteriori dettagli su come attivare o disattivare l'importazione durante la scrittura a livello di prefisso, consulta la sezione Informazioni sull'importazione durante la scrittura.

API REST

API JSON

Per aggiungere, modificare o eliminare il criterio di importazione Rapid Cache in scrittura in una cartella gestita:

  1. Assicurati di aver impostato la proprietà ingestOnWrite nella configurazione della cache. Per sapere a quale valore impostare la proprietà, consulta la sezione Informazioni sull'importazione in scrittura.

  2. Utilizza cURL per chiamare l'API JSON con una richiesta PATCH ManagedFolder. Il corpo della richiesta varia a seconda del caso d'uso:

    Attiva o disattiva il criterio di importazione durante la scrittura per una cartella gestita

    Per aggiornare la configurazione di inserimento durante la scrittura per una o più cache, utilizza il seguente comando:

    curl -X PATCH -H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json" \
-d '{
 "rapidCacheConfig": {
   "policies": {
     "RAPID_CACHE_ID": {
       "rapidCacheId": "RAPID_CACHE_ID",
       "ingestOnWrite": "INGEST_VALUE"
     }
   }
 }
}' \
"https://storage./storage/v1/b/BUCKET_NAME/managedFolders/MANAGED_FOLDER_NAME"

    Sostituisci:

    • BUCKET_NAME: con il nome del bucket che contiene la cartella gestita.

    • MANAGED_FOLDER_NAME: con il nome della cartella gestita.

    • RAPID_CACHE_ID: con l'identificatore della cache, ovvero la zona della cache. Ad esempio, us-east1-b.

    • INGEST_VALUE: con il comportamento di importazione della cache. Quando il valore è enabled, l'inserimento durante la scrittura per i prefissi delle cartelle gestite è abilitato. Quando il valore è unspecified, il comportamento di inserimento in scrittura della cache viene ereditato da una cartella gestita principale, se esiste, o dalla configurazione della cache nel bucket. Per saperne di più sui comportamenti impostati da questi valori, consulta Requisiti di importazione durante la scrittura. Leggi attentamente informazioni sull'ereditarietà dell'inserimento in scrittura per capire in che modo un criterio di inserimento in scrittura di una cache può essere interessato quando l'impostazione ingestOnWrite per la cache è impostata su unspecified.

    Per configurare l'inserimento durante la scrittura per più cache contemporaneamente, includi più mappe policies nella richiesta. Ad esempio:

    "rapidCacheConfig": {
"policies": {
  "us-east1-a": {
    "rapidCacheId": "us-east1-a",
    "ingestOnWrite": "unspecified"
  }
  "us-east1-b": {
    "rapidCacheId": "us-east1-b",
    "ingestOnWrite": "enabled"
  }
}
}

    Per disattivare l'importazione a livello di prefisso in scrittura per le singole cache, rimuovi la mappa policies per la cache dalla configurazione rapidCacheConfig.

    Elimina una policy di importazione durante la scrittura in una cartella gestita

    Puoi eliminare il criterio di importazione durante la scrittura in una cartella gestita seguendo le istruzioni riportate in questa sezione. Quando elimini il criterio di inserimento in scrittura in una cartella gestita, le cache specificate nella richiesta non inseriscono gli oggetti in scrittura in base al prefisso della cartella gestita e il comportamento di inserimento per gli oggetti nel bucket sarà determinato dal campo ingestOnWrite della configurazione della cache. Per scoprire come il comportamento di inserimento durante la scrittura è determinato dal campo ingestOnWrite di una cartella gestita rispetto a una configurazione della cache, consulta Informazioni su come attivare l'inserimento durante la scrittura e Ereditarietà dell'inserimento durante la scrittura.

    Per eliminare la policy di importazione durante la scrittura per una cartella gestita, utilizza il seguente comando. Il seguente comando disattiva l'inserimento durante la scrittura a livello di prefisso nelle singole cache per la risorsa cartella gestita che contiene questa configurazione:

    curl -X PATCH -H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json" \
-d '{
"rapidCacheConfig": {
  "policies": {
    "us-east1-a": null
  }
}
}'
"https://storage./storage/v1/b/BUCKET_NAME/managedFolders/MANAGED_FOLDER_NAME"

    Sostituisci:

    • BUCKET_NAME: con il nome del bucket che contiene la cartella gestita.

    • MANAGED_FOLDER_NAME: con il nome della cartella gestita.

    • RAPID_CACHE_ID: con l'identificatore della cache, ovvero la zona della cache. Ad esempio, us-east1-b. Questo campo deve essere impostato su null.

    In alternativa, per eliminare la policy di importazione in scrittura a livello di prefisso in una cartella gestita, imposta la mappa policies su null nella richiesta:

    "rapidCacheConfig": {
"policies": null
}

Eliminare una cartella gestita

Console

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

    Vai a Bucket

  2. Nell'elenco dei bucket, fai clic sul nome del bucket che contiene la cartella gestita da eliminare.

  3. Nella pagina Dettagli bucket, fai clic sull'icona Altre opzioni accanto alla cartella gestita che vuoi eliminare.

  4. Fai clic su Elimina cartella.

  5. Per confermare l'eliminazione della cartella gestita, digita DELETE nel campo Elimina.

  6. Fai clic su Elimina.

    La cartella gestita e i relativi contenuti, inclusi gli oggetti archiviati e altre cartelle gestite, vengono eliminati dal bucket Cloud Storage.

Riga di comando

Per eliminare una cartella gestita e gli oggetti che contiene, esegui il comando gcloud storage rm:

gcloud storage rm -r gs://BUCKET_NAME/MANAGED_FOLDER_NAME

Dove:

  • BUCKET_NAME è il nome del bucket che contiene la cartella gestita che vuoi eliminare. Ad esempio, my-bucket.

  • MANAGED_FOLDER_NAME è il nome della cartella gestita che vuoi eliminare. Ad esempio, my-managed-folder/.

Librerie client

C++

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

Per eseguire l'autenticazione in Cloud Storage, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client. 

namespace storagecontrol = google::cloud::storagecontrol_v2;
[](storagecontrol::StorageControlClient client,
   std::string const& bucket_name, std::string const& managed_folder_id) {
  auto const name = std::string{"projects/_/buckets/"} + bucket_name +
                    "/managedFolders/" + managed_folder_id;
  auto status = client.DeleteManagedFolder(name);
  if (!status.ok()) throw std::move(status);

  std::cout << "Deleted managed folder: " << managed_folder_id << "\n";
}

C#

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

Per eseguire l'autenticazione in Cloud Storage, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client. 

using Google.Cloud.Storage.Control.V2;
using System;

public class StorageControlDeleteManagedFolderSample
{
    public void StorageControlDeleteManagedFolder(string bucketId = "your-unique-bucket-name",
        string managedFolderId = "your_managed_folder_id")
    {
        StorageControlClient storageControl = StorageControlClient.Create();

        ManagedFolderName managedFolderResourceName =
            // Set project to "_" to signify globally scoped bucket
            new ManagedFolderName("_", bucketId, managedFolderId);

        storageControl.DeleteManagedFolder(managedFolderResourceName);

        Console.WriteLine($"Deleted managed folder {managedFolderId} from bucket {bucketId}");
    }
}

Go

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

Per eseguire l'autenticazione in Cloud Storage, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client. 

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

	control "cloud.google.com/go/storage/control/apiv2"
	"cloud.google.com/go/storage/control/apiv2/controlpb"
)

// deleteManagedFolder deletes the managed folder with the given name.
func deleteManagedFolder(w io.Writer, bucket, folder string) error {
	// bucket := "bucket-name"
	// folder := "managed-folder-name"

	ctx := context.Background()
	client, err := control.NewStorageControlClient(ctx)
	if err != nil {
		return fmt.Errorf("NewStorageControlClient: %w", err)
	}
	defer client.Close()

	ctx, cancel := context.WithTimeout(ctx, time.Second*30)
	defer cancel()

	// Construct folder path including the bucket name.
	folderPath := fmt.Sprintf("projects/_/buckets/%v/managedFolders/%v/", bucket, folder)

	req := &controlpb.DeleteManagedFolderRequest{
		Name: folderPath,
	}
	if err := client.DeleteManagedFolder(ctx, req); err != nil {
		return fmt.Errorf("DeleteManagedFolder(%q): %w", folderPath, err)
	}

	fmt.Fprintf(w, "deleted managed folder %q", folderPath)
	return nil
}

Java

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

Per eseguire l'autenticazione in Cloud Storage, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client. 

import com.google.storage.control.v2.BucketName;
import com.google.storage.control.v2.DeleteManagedFolderRequest;
import com.google.storage.control.v2.ManagedFolderName;
import com.google.storage.control.v2.StorageControlClient;

class DeleteManagedFolder {
  public static void managedFolderDelete(String bucketName, String managedFolderId)
      throws Exception {
    // Instantiates a client in a try-with-resource to automatically cleanup underlying resources
    try (StorageControlClient storageControlClient = StorageControlClient.create()) {
      // Set project to "_" to signify global bucket
      BucketName resourceBucketName = BucketName.of("_", bucketName);
      DeleteManagedFolderRequest deleteManagedFolderRequest =
          DeleteManagedFolderRequest.newBuilder()
              .setName(
                  ManagedFolderName.format(
                      resourceBucketName.getProject(),
                      resourceBucketName.getBucket(),
                      managedFolderId))
              .build();
      storageControlClient.deleteManagedFolder(deleteManagedFolderRequest);
      System.out.printf("Deleted Managed Folder %s%n", managedFolderId);
    }
  }
}

Node.js

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

Per eseguire l'autenticazione in Cloud Storage, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client. 

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */

// The name of your GCS bucket
// const bucketName = 'bucketName';

// The name of the folder to be deleted
// const managedFolderName = 'managedFolderName';

// Imports the Control library
const {StorageControlClient} = require('@google-cloud/storage-control').v2;

// Instantiates a client
const controlClient = new StorageControlClient();

async function callDeleteManagedFolder() {
  const managedFolderPath = controlClient.managedFolderPath(
    '_',
    bucketName,
    managedFolderName
  );

  // Create the request
  const request = {
    name: managedFolderPath,
  };

  // Run request
  await controlClient.deleteManagedFolder(request);
  console.log(`Deleted managed folder: ${managedFolderName}.`);
}

callDeleteManagedFolder();

PHP

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

Per eseguire l'autenticazione in Cloud Storage, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client. 

use Google\Cloud\Storage\Control\V2\Client\StorageControlClient;
use Google\Cloud\Storage\Control\V2\DeleteManagedFolderRequest;

/**
 * Delete a folder in an existing bucket.
 *
 * @param string $bucketName The name of your Cloud Storage bucket.
 *        (e.g. 'my-bucket')
 * @param string $managedFolderId The id of your folder inside the bucket.
 *        (e.g. 'my-folder')
 */
function managed_folder_delete(string $bucketName, string $managedFolderId): void
{
    $storageControlClient = new StorageControlClient();

    // Set project to "_" to signify global bucket
    $formattedName = $storageControlClient->managedFolderName('_', $bucketName, $managedFolderId);

    $request = DeleteManagedFolderRequest::build($formattedName);

    $storageControlClient->deleteManagedFolder($request);

    printf('Deleted Managed Folder %s', $managedFolderId);
}

Python

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

Per eseguire l'autenticazione in Cloud Storage, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client. 

from google.cloud import storage_control_v2


def delete_managed_folder(bucket_name: str, managed_folder_id: str) -> None:
    # The ID of your GCS bucket
    # bucket_name = "your-unique-bucket-name"

    # The name of the managed folder to be deleted
    # managed_folder_id = "managed-folder-name"

    storage_control_client = storage_control_v2.StorageControlClient()
    # The storage bucket path uses the global access pattern, in which the "_"
    # denotes this bucket exists in the global namespace.
    folder_path = storage_control_client.managed_folder_path(
        "_", bucket_name, managed_folder_id
    )

    request = storage_control_v2.DeleteManagedFolderRequest(
        name=folder_path,
    )
    storage_control_client.delete_managed_folder(request=request)

    print(f"Deleted managed folder: {managed_folder_id}")

Ruby

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

Per eseguire l'autenticazione in Cloud Storage, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client. 

def delete_managed_folder bucket_name:, managed_folder_id:
  # The ID of your GCS bucket
  # bucket_name = "your-unique-bucket-name"

  # The name of the managed folder to be created
  # managed_folder_id = "managed-folder-name"

  require "google/cloud/storage/control"

  storage_control = Google::Cloud::Storage::Control.storage_control

  # The storage bucket path uses the global access pattern, in which the "_"
  # denotes this bucket exists in the global namespace.
  folder_path = storage_control.managed_folder_path project: "_",
                                                    bucket: bucket_name,
                                                    managed_folder: managed_folder_id

  request = Google::Cloud::Storage::Control::V2::DeleteManagedFolderRequest.new name: folder_path

  storage_control.delete_managed_folder request

  puts "Deleted managed folder: #{managed_folder_id}"
end

Rust

use google_cloud_storage::client::StorageControl;

pub async fn sample(client: &StorageControl, bucket_id: &str) -> anyhow::Result<()> {
    const ID: &str = "example001";
    client
        .delete_managed_folder()
        .set_name(format!(
            "projects/_/buckets/{bucket_id}/managedFolders/{ID}"
        ))
        .send()
        .await?;
    println!("folder successfully deleted");
    Ok(())
}

API REST

API JSON

Per eliminare una cartella gestita, devi prima eliminare gli oggetti al suo interno.

  1. Avere gcloud CLI installata e inizializzata, il che ti consente di generare un token di accesso per l'intestazione Authorization.

  2. Utilizza cURL per chiamare l'API JSON con una richiesta DELETE ManagedFolder:

    curl -X DELETE -H "Authorization: Bearer $(gcloud auth print-access-token)" \
  "https://storage./storage/v1/b/BUCKET_NAME/managedFolders/MANAGED_FOLDER_NAME"

    Dove:

    • BUCKET_NAME è il nome del bucket che contiene la cartella gestita che vuoi eliminare. Ad esempio, my-bucket.

    • MANAGED_FOLDER_NAME è il nome della cartella gestita che vuoi eliminare. Ad esempio, my-managed-folder/.

    Per impostazione predefinita, le cartelle gestite devono essere vuote prima di poter essere eliminate. Per eliminare una cartella gestita non vuota, includi allowNonEmpty=true come parametro di query nella richiesta.

Risoluzione dei problemi

Per assistenza nella creazione e nella gestione delle cartelle gestite, consulta la pagina di risoluzione dei problemi.

Passaggi successivi