Google utiliza tecnología de IA para traducir contenido a tu idioma preferido. Las traducciones realizadas con IA pueden contener errores.

Crear y gestionar carpetas administradas

En este documento, se describe cómo crear, enumerar, obtener, actualizar y borrar carpetas administradas.

Las carpetas administradas te permiten controlar el acceso a grupos de objetos en tus buckets de Cloud Storage. Para ello, debes configurar de forma selectiva políticas de IAM para los objetos que tienen un prefijo común en sus rutas de acceso de nombre de objeto. Este enfoque te ayuda a cumplir con los requisitos de seguridad y cumplimiento de datos.

Las carpetas administradas también se pueden usar para permitir que las cachés de Rapid Cache ingieran datos en la escritura de forma selectiva por prefijo de nombre de objeto. Para obtener más información, consulta Ingest-on-write.

Antes de comenzar

Para crear y administrar carpetas administradas, primero debes habilitar el acceso uniforme a nivel del bucket y obtener los roles de IAM necesarios.

Habilitar el acceso uniforme a nivel de bucket

Si aún no lo hiciste, habilita el acceso uniforme a nivel de bucket.

Obtén las funciones necesarias

Para obtener los permisos que necesitas para crear y administrar carpetas administradas, pídele a tu administrador que te otorgue el rol de IAM de Administrador de carpetas de almacenamiento (roles/storage.folderAdmin) en el bucket.

Este rol predefinido contiene los permisos necesarios para crear y administrar carpetas administradas. Para ver los permisos exactos que son necesarios, expande la sección Permisos requeridos:

Permisos necesarios

Se requieren los siguientes permisos para crear y administrar carpetas administradas:

Para crear carpetas administradas, haz lo siguiente: storage.managedFolders.create
Para validar las carpetas administradas recién creadas colocándolas en una ficha, haz lo siguiente: storage.objects.list
Para enumerar las carpetas administradas, haz lo siguiente: storage.managedFolders.list
Para obtener carpetas administradas, haz lo siguiente: storage.managedFolders.get
Para mover las carpetas administradas, haz lo siguiente:
- storage.managedFolders.delete (en el bucket de origen)
- storage.managedFolders.create (en el bucket de destino)
Para actualizar las carpetas administradas, haz lo siguiente: storage.managedFolders.update
Para borrar carpetas administradas, haz lo siguiente: storage.managedFolders.delete

Para obtener más información sobre cómo otorgar roles en los buckets, consulta Configura y administra políticas de IAM en buckets.

Crea una carpeta administrada

Console

Cuando usas la consola de Google Cloud , habilitas la administración en carpetas o carpetas simuladas para crear carpetas administradas. En los siguientes pasos, se describe cómo crear una carpeta o una carpeta simulada y, luego, habilitar la administración de carpetas:

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

Ir a Buckets
En la lista de buckets, haz clic en el nombre del bucket en el que deseas crear las carpetas administradas.
En la página Detalles del bucket, haz clic en Crear carpeta para crear una carpeta nueva. Si la carpeta que deseas convertir en una carpeta administrada ya existe, ve al paso en el que se describe cómo acceder al menú Más opciones .
En el campo Nombre, escribe el nombre de tu carpeta. Para obtener consideraciones de nombres, consulta Nombres de carpetas administradas.
Haz clic en Crear.

La carpeta que acabas de crear aparecerá en el panel Navegador de carpetas.
En el panel Navegador de carpetas, haz clic en el menú Más opciones junto con la carpeta que deseas convertir en una carpeta administrada y haz clic en Acceso de edición.

Aparecerá el diálogo ¿Deseas habilitar la administración de carpetas?.
Haz clic en Habilitar.

Tu carpeta se convierte en una carpeta administrada. Aparecerá el panel Permisos para MANAGED_FOLDER_NAME, que muestra las políticas de IAM en la carpeta por principal y rol. Para crear políticas de IAM nuevas, consulta Configura una política de IAM en una carpeta administrada.

Línea de comandos

Para crear una carpeta administrada, ejecuta el comando gcloud storage managed-folders create:

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

Donde:

BUCKET_NAME es el nombre del bucket en el que deseas crear una carpeta administrada. Por ejemplo, my-bucket
MANAGED_FOLDER_NAME es el nombre de la carpeta administrada que deseas crear. Por ejemplo, my-managed-folder/

Para confirmar que se creó la carpeta administrada, ejecuta el comando gcloud storage managed-folders describe:

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

Donde:

BUCKET_NAME es el nombre del bucket en el que creaste una carpeta administrada.
MANAGED_FOLDER_NAME es el nombre de la carpeta administrada que creaste.

Bibliotecas cliente

C++

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

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente.

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#

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

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente.

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

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

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente.

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

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

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente.


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

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

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente.

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

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

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente.

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

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

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente.

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

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

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente.

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 de REST

API de JSON

Tener la gcloud CLI instalada e inicializada, lo que te permite generar un token de acceso para el encabezado Authorization
Usa cURL para llamar a la API de JSON con una solicitud de ManagedFolder POST:
```
curl -X POST -H "Authorization: Bearer $(gcloud auth print-access-token)" \
-d '{ "name": "MANAGED_FOLDER_NAME" }' \
  "https://storage./storage/v1/b/BUCKET_NAME/managedFolders"
```
Aquí:
- MANAGED_FOLDER_NAME es el nombre de la carpeta administrada que deseas crear. Por ejemplo, my-managed-folder/.
- BUCKET_NAME es el nombre del bucket en el que deseas crear una carpeta administrada. Por ejemplo, my-bucket.
Crea una carpeta administrada para habilitar la transferencia de Rapid Cache en el momento de la escritura

En esta sección, se describe cómo crear una carpeta administrada con parámetros de configuración que habiliten la función de transferencia en escritura de Rapid Cache a nivel del prefijo. Si no usas Rapid Cache ni su función de transferencia en escritura, omite esta sección.

Si deseas crear una carpeta administrada para habilitar la ingesta a nivel de prefijo en la escritura para las cachés creadas con Rapid Cache, haz lo siguiente:
1. Lee Cómo habilitar la escritura en el momento de la transferencia para familiarizarte con la configuración de la escritura en el momento de la transferencia a nivel del prefijo.
2. Asegúrate de que la propiedad ingestOnWrite de la caché esté establecida en false. Para obtener instrucciones, consulta Cómo actualizar una caché.
3. Incluye una configuración de rapidCacheConfig en tu solicitud:
```
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"
```
Aquí:
- MANAGED_FOLDER_NAME es el nombre de la carpeta administrada que deseas crear. La caché usa este nombre de carpeta administrada para transferir objetos de forma selectiva durante la escritura. Por ejemplo, si especificas my-managed-folder/ como el nombre de la carpeta administrada, la caché solo incorporará los objetos del bucket cuyo nombre incluya my-managed-folder/ en su ruta de acceso.
- RAPID_CACHE_ID es el identificador de la caché, que es la zona de la caché. Por ejemplo, us-east1-b La caché que especifiques debe estar asociada al bucket en el que se está creando la carpeta administrada. Para encontrar las cachés asociadas a un bucket, enumera las cachés del bucket.
- BUCKET_NAME es el nombre del bucket asociado con la caché. Por ejemplo, my-cached-bucket La carpeta administrada se creará en este bucket.

Enumera carpetas administradas

Console

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

Ir a Buckets
En el panel Navegador de carpetas, usa el nodo de activar o desactivar para expandir la lista de carpetas dentro de tu bucket.

Una lista muestra las carpetas, las carpetas simuladas y las carpetas administradas de tu bucket.

Línea de comandos

Para enumerar las carpetas administradas, ejecuta el comando gcloud storage managed-folders list:

gcloud storage managed-folders list gs://BUCKET_NAME

Donde:

BUCKET_NAME es el nombre del depósito que contiene las carpetas administradas que deseas enumerar. Por ejemplo, my-bucket

Ten en cuenta que también puedes especificar una ruta de acceso a la carpeta en lugar de un nombre de bucket. Por ejemplo:

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

Bibliotecas cliente

C++

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

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente.

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#

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

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente.

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

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

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente.

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

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

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente.


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

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

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente.

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

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

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente.

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

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

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente.

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

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

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente.

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 de REST

API de JSON

Tener la gcloud CLI instalada e inicializada, lo que te permite generar un token de acceso para el encabezado Authorization
Usa cURL para llamar a la API de JSON con una solicitud para enumerar las carpetas administradas:
```
curl -X GET -H "Authorization: Bearer $(gcloud auth print-access-token)" \
"https://storage./storage/v1/b/BUCKET_NAME/managedFolders"
```
BUCKET_NAME es el nombre del bucket que contiene las carpetas administradas que deseas enumerar. Por ejemplo, my-bucket

Obtén los metadatos de una carpeta administrada

Línea de comandos

Para obtener los metadatos de una carpeta administrada, ejecuta el comando gcloud storage managed-folders describe:

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

Donde:

BUCKET_NAME es el nombre del depósito que contiene las carpetas administradas que deseas enumerar. Por ejemplo, my-bucket
MANAGED_FOLDER_NAME es el nombre de la carpeta administrada de la que deseas recuperar metadatos.

Bibliotecas cliente

C++

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

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente.

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#

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

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente.

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

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

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente.

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

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

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente.


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

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

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente.

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

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

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente.

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

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

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente.

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

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

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente.

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 de REST

API de JSON

Tener la gcloud CLI instalada e inicializada, lo que te permite generar un token de acceso para el encabezado Authorization
Usa cURL para llamar a la API de JSON con una solicitud para obtener las carpetas administradas:
```
curl -X GET -H "Authorization: Bearer $(gcloud auth print-access-token)" \
"https://storage./storage/v1/b/BUCKET_NAME/managedFolders/MANAGED_FOLDER_NAME"
```
Donde:
- BUCKET_NAME es el nombre del bucket que contiene las carpetas administradas que deseas obtener. Por ejemplo, my-bucket
- MANAGED_FOLDER_NAME es el nombre de la carpeta administrada expresado como una ruta de acceso. Por ejemplo, example-dir/ Si la carpeta administrada está anidada, se debe usar el carácter de barra oblicua (/) como formato de escape en la ruta de acceso de la carpeta administrada. Por ejemplo, example-dir1%2Fexample-dir2.

Mover una carpeta administrada

Console

Crea una carpeta administrada nueva en el bucket de destino.
Copia las políticas de IAM de la carpeta administrada original en el bucket de origen a la carpeta administrada nueva en el bucket de destino.
Copia los objetos de la carpeta administrada original en el bucket de origen a la nueva carpeta administrada en el bucket de destino.
Borra la carpeta administrada original del bucket de origen.

Línea de comandos

Para mover las carpetas administradas y los objetos que contienen, ejecuta el comando gcloud storage mv con la opción --include-managed-folders:

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

Donde:

SOURCE_BUCKET es el nombre de tu bucket original. Por ejemplo: my-source-bucket`.
DESTINATION_BUCKET es el nombre del bucket al que mueves tu carpeta administrada. Por ejemplo, my-destination-bucket
MANAGED_FOLDER_NAME es el nombre de la carpeta administrada que mueves. Por ejemplo, my-managed-folder/

API de REST

API de JSON

Para mover las carpetas administradas de un bucket a otro, completa los siguientes pasos:

Crea una carpeta administrada nueva en el bucket de destino.
Copia las políticas de IAM desde la carpeta administrada original en el bucket de origen a la nueva carpeta administrada en el bucket de destino.
Copia los objetos de la carpeta administrada original en el bucket de origen a la nueva carpeta administrada en el bucket de destino.
Borra la carpeta administrada original del bucket de origen.

Actualiza la política de Rapid Cache de ingreso en escritura en una carpeta administrada

En esta sección, se describe cómo habilitar o inhabilitar el parámetro de configuración de Rapid Cache ingest-on-write a nivel del prefijo, que usa carpetas administradas como mecanismo subyacente. Si no usas Rapid Cache ni su función de transferencia en escritura, omite esta sección.

Para habilitar o inhabilitar la política de transferencia en escritura de Rapid Cache para los objetos que comparten un prefijo de carpeta administrada, debes actualizar la configuración de rapidCacheConfig de la carpeta administrada. Estas instrucciones solo son necesarias cuando usas la API de JSON para actualizar la política de transferencia en escritura de una caché.

Para obtener más detalles sobre cómo habilitar o inhabilitar la incorporación en la escritura a nivel del prefijo, consulta Información sobre la incorporación en la escritura.

API de REST

API de JSON

Para agregar, modificar o borrar la política de Rapid Cache de transferencia en escritura en una carpeta administrada, haz lo siguiente:

Asegúrate de configurar la propiedad ingestOnWrite en la configuración de la caché. Consulta Información sobre la escritura durante la transferencia para saber qué valor configurar en la propiedad.
Usa cURL para llamar a la API de JSON con una solicitud de PATCH ManagedFolder. El cuerpo de la solicitud varía según tu caso de uso:

Habilita o inhabilita la política de transferencia en escritura para una carpeta administrada

Para actualizar la configuración de la transferencia en escritura de una o varias cachés, usa el siguiente 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"
```
Reemplaza lo siguiente:
- BUCKET_NAME: con el nombre del bucket que contiene la carpeta administrada.
- MANAGED_FOLDER_NAME: con el nombre de la carpeta administrada.
- RAPID_CACHE_ID: con el identificador de la caché, que es la zona de la caché. Por ejemplo, us-east1-b
- INGEST_VALUE: Con el comportamiento de la caché durante la transferencia. Cuando el valor es enabled, se habilita la escritura durante la transferencia para los prefijos de carpetas administradas. Cuando el valor es unspecified, el comportamiento de la caché de transferencia en escritura se hereda de una carpeta administrada principal, si existe, o de la configuración de la caché en el bucket. Para obtener más información sobre los comportamientos establecidos por estos valores, consulta Requisitos de la escritura durante la transferencia. Lee atentamente sobre la herencia de la escritura en la transferencia para comprender cómo se puede ver afectada la política de escritura en la transferencia de una caché cuando el parámetro de configuración ingestOnWrite de la caché se establece en unspecified.
Para configurar la transferencia en escritura para varias cachés a la vez, incluye varios mapas policies en tu solicitud. Por ejemplo:
```
"rapidCacheConfig": {
"policies": {
  "us-east1-a": {
    "rapidCacheId": "us-east1-a",
    "ingestOnWrite": "unspecified"
  }
  "us-east1-b": {
    "rapidCacheId": "us-east1-b",
    "ingestOnWrite": "enabled"
  }
}
}
```
Para inhabilitar la transferencia a nivel del prefijo en la escritura para cachés individuales, quita el mapa policies de la caché de la configuración rapidCacheConfig.

Borra una política de escritura durante la transferencia en una carpeta administrada

Puedes borrar la política de transferencia en escritura en una carpeta administrada siguiendo las instrucciones de esta sección. Cuando borras la política de transferencia en escritura en una carpeta administrada, las cachés que especificas en tu solicitud no transferirán objetos en escritura por su prefijo de carpeta administrada, y el comportamiento de transferencia para los objetos en el bucket se determinará según el campo ingestOnWrite de la configuración de la caché. Para obtener información sobre cómo el campo ingestOnWrite de una carpeta administrada determina el comportamiento de la transferencia en escritura en comparación con una configuración de caché, consulta Cómo habilitar la transferencia en escritura y Herencia de la transferencia en escritura.

Para borrar la política de incorporación en escritura de una carpeta administrada, usa el siguiente comando. El siguiente comando inhabilita la transferencia en el momento de la escritura a nivel del prefijo en cachés individuales para el recurso de carpeta administrada que contiene esta configuración:
```
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"
```
Reemplaza lo siguiente:
- BUCKET_NAME: con el nombre del bucket que contiene la carpeta administrada.
- MANAGED_FOLDER_NAME: con el nombre de la carpeta administrada.
- RAPID_CACHE_ID: con el identificador de la caché, que es la zona de la caché. Por ejemplo, us-east1-b Este campo debe establecerse en null.
Como alternativa, para borrar la política de escritura durante la transferencia a nivel del prefijo en una carpeta administrada, establece el mapa policies en null en tu solicitud:
```
"rapidCacheConfig": {
"policies": null
}
```

Borrar una carpeta administrada

Console

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

Ir a Buckets
En la lista de buckets, haz clic en el nombre del bucket que contiene la carpeta administrada que deseas borrar.
En la página Detalles del bucket , haz clic en el ícono Más opciones junto con la carpeta administrada que deseas borrar.
Haz clic en Borrar carpeta.
Para confirmar que deseas borrar la carpeta administrada, escribe DELETE en el campo Borrar.
Haz clic en Borrar.

La carpeta administrada y su contenido, incluidos los objetos almacenados y otras carpetas administradas, se borran de tu bucket de Cloud Storage.

Línea de comandos

Para borrar una carpeta administrada y los objetos que contiene, ejecuta el comando gcloud storage rm:

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

Donde:

BUCKET_NAME es el nombre del bucket que contiene la carpeta administrada que deseas borrar. Por ejemplo, my-bucket
MANAGED_FOLDER_NAME es el nombre de la carpeta administrada que deseas borrar. Por ejemplo, my-managed-folder/

Bibliotecas cliente

C++

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

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente.

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#

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

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente.

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

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

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente.

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

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

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente.

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

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

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente.

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

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

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente.

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

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

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente.

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

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

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente.

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 de REST

API de JSON

Para borrar una carpeta administrada, primero debes borrar los objetos dentro de la carpeta administrada.

Tener la gcloud CLI instalada e inicializada, lo que te permite generar un token de acceso para el encabezado Authorization
Usa cURL para llamar a la API de JSON con una solicitud de ManagedFolder DELETE:
```
curl -X DELETE -H "Authorization: Bearer $(gcloud auth print-access-token)" \
  "https://storage./storage/v1/b/BUCKET_NAME/managedFolders/MANAGED_FOLDER_NAME"
```
Donde:
- BUCKET_NAME es el nombre del bucket que contiene la carpeta administrada que deseas borrar. Por ejemplo, my-bucket.
- MANAGED_FOLDER_NAME es el nombre de la carpeta administrada que deseas borrar. Por ejemplo, my-managed-folder/
De forma predeterminada, las carpetas administradas deben estar vacías antes de que puedan borrarse. Para borrar una carpeta administrada que no esté vacía, incluye allowNonEmpty=true como parámetro de consulta en tu solicitud.

Soluciona problemas

Si deseas obtener ayuda para crear y administrar carpetas administradas, consulta la página de solución de problemas.

¿Qué sigue?

Configura una política de IAM en una carpeta administrada.
Enumera objetos en carpetas administradas.
Obtén más información sobre las prácticas recomendadas para usar carpetas administradas.

Crear y gestionar carpetas administradas Organiza tus páginas con colecciones Guarda y categoriza el contenido según tus preferencias.

Antes de comenzar

Habilitar el acceso uniforme a nivel de bucket

Obtén las funciones necesarias

Permisos necesarios

Crea una carpeta administrada

Console

Línea de comandos

Bibliotecas cliente

C++

C#

Go

Java

Node.js

PHP

Python

Ruby

Rust

API de REST

API de JSON

Crea una carpeta administrada para habilitar la transferencia de Rapid Cache en el momento de la escritura

Enumera carpetas administradas

Console

Línea de comandos

Bibliotecas cliente

C++

C#

Go

Java

Node.js

PHP

Python

Ruby

Rust

API de REST

API de JSON

Obtén los metadatos de una carpeta administrada

Línea de comandos

Bibliotecas cliente

C++

C#

Go

Java

Node.js

PHP

Python

Ruby

Rust

API de REST

API de JSON

Mover una carpeta administrada

Console

Línea de comandos

API de REST

API de JSON

Actualiza la política de Rapid Cache de ingreso en escritura en una carpeta administrada

API de REST

API de JSON

Habilita o inhabilita la política de transferencia en escritura para una carpeta administrada

Borra una política de escritura durante la transferencia en una carpeta administrada

Borrar una carpeta administrada

Console

Línea de comandos

Bibliotecas cliente

C++

C#

Go

Java

Node.js

PHP

Python

Ruby

Rust

API de REST

API de JSON

Soluciona problemas

¿Qué sigue?

Crear y gestionar carpetas administradas