Esta página se ha traducido con Cloud Translation API.

Crear y gestionar carpetas

En esta página se describe cómo crear, enumerar, subir, eliminar y obtener metadatos de carpetas en los contenedores con el espacio de nombres jerárquico habilitado.

Antes de empezar

Asegúrate de que el espacio de nombres jerárquico esté habilitado en tu segmento. Para obtener instrucciones detalladas sobre cómo habilitar el espacio de nombres jerárquico en un segmento, consulta Crear segmentos con el espacio de nombres jerárquico habilitado.

Crear una carpeta

En esta sección se describe cómo crear una carpeta.

Roles necesarios

Para obtener los permisos necesarios para crear carpetas, pide a tu administrador que te conceda el rol de gestión de identidades y accesos Usuario de objetos de Storage (roles/storage.objectUser) en el segmento. Este rol incluye el permiso storage.folders.create, que es necesario para crear una carpeta.

Para obtener instrucciones sobre cómo conceder roles en los contenedores, consulta el artículo Usar gestión de identidades y accesos con contenedores.

También puedes obtener este permiso con otros roles personalizados o roles predefinidos. Si quieres un rol más permisivo que te permita gestionar carpetas además de crearlas, pide a tu administrador que te conceda uno de los siguientes roles:

Administrador de carpetas de almacenamiento (roles/storage.folderAdmin)
Administrador de objetos de Storage (roles/storage.objectAdmin)
Administrador de almacenamiento (roles/storage.admin)

Para ver qué roles están asociados a qué permisos, consulta Roles de gestión de identidades y accesos de Cloud Storage.

Consola

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

Ir a Contenedores
En la lista de segmentos, haga clic en el nombre del segmento en el que quiera crear la carpeta.
En la página Detalles del contenedor, haga clic en Crear carpeta para crear una carpeta vacía.
En el campo Nombre, escribe el nombre de la carpeta. Para obtener información sobre la nomenclatura, consulta la sección Consideraciones.
Haz clic en Crear.
La carpeta que has creado aparecerá en el panel Explorador de carpetas.

Línea de comandos

In the Google Cloud console, activate Cloud Shell.

Activate Cloud Shell

At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.
En tu entorno de desarrollo, ejecuta el comando gcloud storage folders create:
```
gcloud storage folders create --recursive gs://BUCKET_NAME/FOLDER_NAME
```
Donde:
- BUCKET_NAME es el nombre de tu segmento. Por ejemplo, my-bucket.
- FOLDER_NAME es el nombre de la carpeta que quieres crear. Por ejemplo, my-folder/. Para obtener información sobre los nombres de las carpetas, consulta la documentación general sobre carpetas.
- --recursive es una marca que crea automáticamente todas las carpetas superiores que no existan junto con la carpeta. Este ajuste es opcional si ya existen carpetas principales.
Si la solicitud se realiza correctamente, el comando devuelve el siguiente mensaje:
```
Completed 1/1
```

Bibliotecas de cliente

C++

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

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación para bibliotecas de cliente.

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

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

C#

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

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

public class StorageControlCreateFolderSample
{
    public Folder StorageControlCreateFolder(string bucketName = "your-unique-bucket-name",
        string folderName = "your_folder_name")
    {
        StorageControlClient storageControl = StorageControlClient.Create();

        var request = new CreateFolderRequest
        {
            // Set project to "_" to signify globally scoped bucket
            Parent = BucketName.FormatProjectBucket("_", bucketName),
            FolderId = folderName
        };

        Folder folder = storageControl.CreateFolder(request);

        Console.WriteLine($"Folder {folderName} created in bucket {bucketName}");
        return folder;
    }
}

Go

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

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

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

// createFolder creates a folder in the bucket with the given name.
func createFolder(w io.Writer, bucket, folder string) error {
	// bucket := "bucket-name"
	// folder := "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()

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

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

Java

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

import com.google.storage.control.v2.BucketName;
import com.google.storage.control.v2.CreateFolderRequest;
import com.google.storage.control.v2.Folder;
import com.google.storage.control.v2.StorageControlClient;
import java.io.IOException;

public final class CreateFolder {

  public static void createFolder(String bucketName, String folderName) throws IOException {
    // The name of the bucket
    // String bucketName = "your-unique-bucket-name";

    // The name of the folder within the bucket
    // String folderName = "your-unique-folder-name";

    try (StorageControlClient storageControl = StorageControlClient.create()) {

      CreateFolderRequest request =
          CreateFolderRequest.newBuilder()
              // Set project to "_" to signify globally scoped bucket
              .setParent(BucketName.format("_", bucketName))
              .setFolderId(folderName)
              .build();

      Folder newFolder = storageControl.createFolder(request);

      System.out.printf("Created folder: %s%n", newFolder.getName());
    }
  }
}

Node.js

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

/**
 * 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 created
// const folderName = 'folderName';

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

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

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

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

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

callCreateFolder();

PHP

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

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

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

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

    $request = new CreateFolderRequest([
        'parent' => $formattedName,
        'folder_id' => $folderName,
    ]);

    $folder = $storageControlClient->createFolder($request);

    printf('Created folder: %s', $folder->getName());
}

Python

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

from google.cloud import storage_control_v2


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

    # The name of the folder to be created
    # folder_name = "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.CreateFolderRequest(
        parent=bucket_path,
        folder_id=folder_name,
    )
    response = storage_control_client.create_folder(request=request)

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

Ruby

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

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

  # The name of the folder to be created
  # folder_name = "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::CreateFolderRequest.new parent: bucket_path, folder_id: folder_name

  response = storage_control.create_folder request

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

APIs REST

API JSON

Tener instalada e inicializada la CLI de gcloud, que te permite generar un token de acceso para el encabezado Authorization.

Crea un archivo JSON que contenga los ajustes de la carpeta, que debe incluir un name para la carpeta. Consulta la documentación de Carpetas: Insertar para ver la lista completa de ajustes. Debes incluir los siguientes ajustes:
```
{
  "name": "FOLDER_NAME",
}
```
Donde FOLDER_NAME es el nombre de la carpeta que quieres crear. Por ejemplo, my-folder/. Para obtener información sobre los nombres de las carpetas, consulta la documentación general sobre carpetas.
Usa cURL para llamar a la API JSON:
```
curl -X POST --data-binary @JSON_FILE_NAME \
  -H "Authorization: Bearer $(gcloud auth print-access-token)" \
  -H "Content-Type: application/json" \
  "https://storage.googleapis.com/storage/v1/b/BUCKET_NAME/folders?recursive=true"
```
Donde:
- JSON_FILE_NAME es el nombre del archivo JSON que contiene la configuración de la carpeta.
- BUCKET_NAME es el nombre del contenedor en el que quieres crear la carpeta.
- recursive se define como "true" para crear automáticamente todas las carpetas superiores que no existan junto con la carpeta. Este ajuste es opcional si ya existen carpetas principales.

Mostrar carpetas

En esta sección se describe cómo enumerar carpetas.

Roles necesarios

Para obtener los permisos necesarios para enumerar carpetas, pide a tu administrador que te conceda el rol de gestión de identidades y accesos Lector de objetos de Storage (roles/storage.objectViewer) en el segmento. Este rol contiene el permiso storage.folders.list, que es necesario para listar carpetas.

Para obtener instrucciones sobre cómo conceder roles en los contenedores, consulta el artículo Usar gestión de identidades y accesos con contenedores.

También puedes obtener este permiso con otros roles personalizados o roles predefinidos. Si quieres un rol más permisivo que te permita gestionar carpetas además de enumerarlas, pide a tu administrador que te conceda uno de los siguientes roles:

Administrador de carpetas de almacenamiento (roles/storage.folderAdmin)
Administrador de objetos de Storage (roles/storage.objectAdmin)
Usuario de objetos de Storage (roles/storage.objectUser)
Administrador de almacenamiento (roles/storage.admin)

Para ver qué roles están asociados a qué permisos, consulta Roles de gestión de identidades y accesos de Cloud Storage.

Consola

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

Ir a Contenedores
En la lista de segmentos, haga clic en el nombre del segmento cuyas carpetas quiera consultar.
En el panel Explorador de carpetas, usa la flecha de expansión para desplegar la lista de carpetas de tu contenedor.

Se muestra una lista con las carpetas, las carpetas simuladas y las carpetas gestionadas de tu contenedor.

Línea de comandos

Para enumerar todas las carpetas de un contenedor, ejecuta el comando gcloud storage folders list:

gcloud storage folders list gs://BUCKET_NAME/

Donde:

BUCKET_NAME es el nombre del segmento que contiene las carpetas que quieres enumerar. Por ejemplo, my-bucket.

Una respuesta correcta tiene el siguiente aspecto:

bucket: hns-bucket
id: hns-bucket/A/
kind: storage#folder
name: A/
selfLink: https://www.googleapis.com/storage/v1/b/hns-bucket/f/A
timeCreated: '2023-05-05T16:32:08.878000+00:00'
updated: '2023-05-05T16:32:08.878000+00:00'
---
bucket: hns-bucket
id: hns-bucket/B/
kind: storage#folder
name: B/
selfLink: https://www.googleapis.com/storage/v1/b/hns-bucket/f/B
timeCreated: '2023-05-05T16:32:08.878000+00:00'
updated: '2023-05-05T16:32:08.878000+00:00'
---
bucket: hns-bucket
id: hns-bucket/B/D/
kind: storage#folder
name: D/
selfLink: https://www.googleapis.com/storage/v1/b/hns-bucket/f/B/D
timeCreated: '2023-05-05T16:32:08.878000+00:00'
updated: '2023-05-05T16:32:08.878000+00:00'
---
bucket: hns-bucket
id: hns-bucket/C/
kind: storage#folder
name: C/
selfLink: https://www.googleapis.com/storage/v1/b/hns-bucket/f/C
timeCreated: '2023-05-05T16:32:08.878000+00:00'
updated: '2023-05-05T16:32:08.878000+00:00'
---
bucket: hns-bucket
id: hns-bucket/C/E/
kind: storage#folder
name: E/
selfLink: https://www.googleapis.com/storage/v1/b/hns-bucket/f/C/E
timeCreated: '2023-05-05T16:32:08.878000+00:00'
updated: '2023-05-05T16:32:08.878000+00:00'
...

Bibliotecas de cliente

C++

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

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 folder : client.ListFolders(parent)) {
    if (!folder) throw std::move(folder).status();
    std::cout << folder->name() << "\n";
  }

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

C#

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

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

public class StorageControlListFoldersSample
{
    public IEnumerable<Folder> StorageControlListFolders(string bucketName = "your-unique-bucket-name")
    {
        StorageControlClient storageControl = StorageControlClient.Create();

        // Use "_" for project ID to signify globally scoped bucket
        string bucketResourceName = BucketName.FormatProjectBucket("_", bucketName);
        var folders = storageControl.ListFolders(bucketResourceName);

        foreach (var folder in folders)
        {
            Console.Write(folder.Name);
        }
        return folders;
    }
}

Go

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

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"
)

// listFolders lists all folders present in the bucket.
func listFolders(w io.Writer, bucket string) error {
	// bucket := "bucket-name"
	// folder := "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.ListFoldersRequest{
		Parent: bucketPath,
	}
	it := client.ListFolders(ctx, req)
	for {
		f, err := it.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			return fmt.Errorf("ListFolders(%q): %w", bucketPath, err)
		}
		fmt.Fprintf(w, "got folder %v\n", f.Name)
	}

	return nil
}

Java

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


import com.google.storage.control.v2.BucketName;
import com.google.storage.control.v2.Folder;
import com.google.storage.control.v2.ListFoldersRequest;
import com.google.storage.control.v2.StorageControlClient;
import java.io.IOException;

public final class ListFolders {

  public static void listFolders(String bucketName) throws IOException {
    // The name of the bucket
    // String bucketName = "your-unique-bucket-name";

    try (StorageControlClient storageControl = StorageControlClient.create()) {

      ListFoldersRequest request =
          ListFoldersRequest.newBuilder()
              // Set project to "_" to signify globally scoped bucket
              .setParent(BucketName.format("_", bucketName))
              .build();

      Iterable<Folder> folders = storageControl.listFolders(request).iterateAll();
      for (Folder folder : folders) {
        System.out.printf("Found folder: %s%n", folder.getName());
      }
    }
  }
}

Node.js

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

/**
 * 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 callListFolders() {
  const bucketPath = controlClient.bucketPath('_', bucketName);

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

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

callListFolders();

PHP

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

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

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

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

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

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

    foreach ($folders as $folder) {
        printf('Folder name: %s' . PHP_EOL, $folder->getName());
    }
}

Python

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

from google.cloud import storage_control_v2


def list_folders(bucket_name: str) -> None:
    # The ID of your GCS bucket
    # bucket_name = "your-unique-bucket-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.ListFoldersRequest(
        parent=bucket_path,
    )

    page_result = storage_control_client.list_folders(request=request)
    for folder in page_result:
        print(folder)

    print(f"Listed folders in bucket {bucket_name}")

Ruby

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

def list_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::ListFoldersRequest.new parent: bucket_path

  response = storage_control.list_folders request

  puts response.response.folders
end

APIs REST

API JSON

Tener instalada e inicializada la CLI de gcloud, que te permite generar un token de acceso para el encabezado Authorization.

Usa cURL para llamar a la API JSON con una solicitud para enumerar carpetas:
```
curl -X GET -H "Authorization: Bearer $(gcloud auth print-access-token)" \
"https://storage.googleapis.com/storage/v1/b/BUCKET_NAME/folders"
```
Donde BUCKET_NAME es el nombre del segmento que contiene las carpetas que quieres enumerar. Por ejemplo, my-bucket.

Subir una carpeta

En esta sección se describe cómo subir carpetas a un contenedor.

Roles necesarios

Para obtener los permisos necesarios para subir carpetas, pide a tu administrador que te conceda el rol de gestión de identidades y accesos de usuario de objetos de Storage (roles/storage.objectUser) en el segmento. Este rol contiene el permiso storage.folders.create, que es necesario para subir una carpeta.

Para obtener instrucciones sobre cómo conceder roles en los contenedores, consulta el artículo Usar gestión de identidades y accesos con contenedores.

También puedes obtener este permiso con otros roles personalizados o roles predefinidos. Si quieres un rol con más permisos que te permita gestionar carpetas además de subirlas, pide a tu administrador que te conceda uno de los siguientes roles:

Administrador de carpetas de almacenamiento (roles/storage.folderAdmin)
Administrador de objetos de Storage (roles/storage.objectAdmin)
Administrador de almacenamiento (roles/storage.admin)

Para ver qué roles están asociados a qué permisos, consulta Roles de gestión de identidades y accesos de Cloud Storage.

Consola

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

Ir a Contenedores
En la lista de segmentos, haga clic en el nombre del segmento al que quiera subir la carpeta.
En la pestaña Detalles del contenedor, realice una de las siguientes acciones:
- Arrastra carpetas desde el escritorio o el gestor de archivos al panel principal de la Google Cloud consola.
- Haz clic en Subir > Subir carpeta, selecciona la carpeta que quieras subir en el cuadro de diálogo que aparece y, a continuación, haz clic en Abrir.

Para saber cómo obtener información detallada sobre los errores de las operaciones de Cloud Storage en la consola, consulta la sección Solución de problemas. Google Cloud

Línea de comandos

Usa el comando gcloud storage cp con la marca --recursive:

gcloud storage cp --recursive FOLDER_LOCATION gs://DESTINATION_BUCKET_NAME

Donde:

FOLDER_LOCATION es la ruta local a la carpeta que quieres subir. Por ejemplo, ../uploads/my-folder/.
DESTINATION_BUCKET_NAME es el nombre del contenedor al que vas a subir la carpeta. Por ejemplo, my-bucket.

Si la acción se realiza correctamente, la respuesta se parecerá al siguiente ejemplo:

Copying file://DIR/OBJ1 at 10.06.32 PM.png to gs://BUCKET_NAME/DIR/OBJ1 at 10.06.32 PM.png
Copying file://DIR/OBJ1 at 10.06.32 PM.png to gs://BUCKET_NAME/DIR/OBJ1 at 10.06.32 PM.png
Completed files 2/2 | 1.7MiB/1.7MiB

Eliminar una carpeta

En esta sección se describe cómo eliminar carpetas.

Roles necesarios

Para obtener los permisos necesarios para eliminar carpetas, pide a tu administrador que te conceda el rol de gestión de identidades y accesos Usuario de objetos de Storage (roles/storage.objectUser) en el segmento. Este rol contiene los siguientes permisos, que son necesarios para eliminar una carpeta:

storage.folders.delete
storage.managedFolders.delete (Solo es necesario si existe una carpeta gestionada con la misma ruta que la carpeta)

Para obtener instrucciones sobre cómo conceder roles en los contenedores, consulta el artículo Usar gestión de identidades y accesos con contenedores.

También puedes obtener estos permisos con otros roles personalizados o roles predefinidos. Si quieres tener un rol con más permisos que te permita gestionar carpetas además de eliminarlas, pide a tu administrador que te conceda uno de los siguientes roles:

Administrador de carpetas de almacenamiento (roles/storage.folderAdmin)
Administrador de objetos de Storage (roles/storage.objectAdmin)
Administrador de almacenamiento (roles/storage.admin)

Para ver qué roles están asociados a qué permisos, consulta los roles de gestión de identidades y accesos de Cloud Storage.

Consola

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

Ir a Contenedores
En la lista de segmentos, haga clic en el nombre del segmento cuyas carpetas quiera eliminar.
En el panel Explorador de carpetas, usa la flecha de expansión para desplegar la lista de carpetas de tu contenedor.
Busca la carpeta que quieras eliminar.
Haz clic en el menú Más opciones de la carpeta.
Haz clic en Eliminar carpeta.
Para confirmar que quieres eliminar la carpeta, escribe DELETE en el campo Eliminar.
Haz clic en Eliminar.

La carpeta y su contenido, incluidos los objetos almacenados y otras carpetas gestionadas, se eliminan de tu segmento de Cloud Storage.

Línea de comandos

Para eliminar una carpeta vacía, ejecuta el comando gcloud storage folders delete:

gcloud storage folders delete gs://BUCKET_NAME/FOLDER_NAME

Donde:

BUCKET_NAME es el nombre del segmento. Por ejemplo, my-bucket.
FOLDER_NAME es el nombre de la carpeta que quieres eliminar. Por ejemplo, my-folder/.

Bibliotecas de cliente

C++

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

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

  std::cout << "Deleted folder: " << folder_id << "\n";
}

C#

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

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

public class StorageControlDeleteFolderSample
{
    public void StorageControlDeleteFolder(string bucketName = "your-unique-bucket-name",
        string folderName = "your_folder_name")
    {
        StorageControlClient storageControl = StorageControlClient.Create();

        string folderResourceName =
            // Set project to "_" to signify globally scoped bucket
            FolderName.FormatProjectBucketFolder("_", bucketName, folderName);

        storageControl.DeleteFolder(folderResourceName);

        Console.WriteLine($"Deleted folder {folderName} from bucket {bucketName}");
    }
}

Go

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

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

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

// deleteFolder deletes the folder with the given name.
func deleteFolder(w io.Writer, bucket, folder string) error {
	// bucket := "bucket-name"
	// folder := "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/folders/%v", bucket, folder)

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

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

Java

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


import com.google.storage.control.v2.DeleteFolderRequest;
import com.google.storage.control.v2.FolderName;
import com.google.storage.control.v2.StorageControlClient;
import java.io.IOException;

public final class DeleteFolder {

  public static void deleteFolder(String bucketName, String folderName) throws IOException {
    // The name of the bucket
    // String bucketName = "your-unique-bucket-name";

    // The name of the folder within the bucket
    // String folderName = "your-unique-folder-name";

    try (StorageControlClient storageControl = StorageControlClient.create()) {

      // Set project to "_" to signify globally scoped bucket
      String folderResourceName = FolderName.format("_", bucketName, folderName);
      DeleteFolderRequest request =
          DeleteFolderRequest.newBuilder().setName(folderResourceName).build();

      storageControl.deleteFolder(request);

      System.out.printf("Deleted folder: %s%n", folderResourceName);
    }
  }
}

Node.js

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

/**
 * 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 folderName = 'folderName';

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

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

async function callDeleteFolder() {
  const folderPath = controlClient.folderPath('_', bucketName, folderName);

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

  // Run request
  await controlClient.deleteFolder(request);
  console.log(`Deleted folder: ${folderName}.`);
}

callDeleteFolder();

PHP

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

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

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

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

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

    $storageControlClient->deleteFolder($request);

    printf('Deleted folder: %s', $folderName);
}

Python

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

from google.cloud import storage_control_v2


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

    # The name of the folder to be deleted
    # folder_name = "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.folder_path(
        project="_", bucket=bucket_name, folder=folder_name
    )

    request = storage_control_v2.DeleteFolderRequest(
        name=folder_path,
    )
    storage_control_client.delete_folder(request=request)

    print(f"Deleted folder {folder_name}")

Ruby

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

def delete_folder bucket_name:, folder_name:
  # The ID of your GCS bucket
  # bucket_name = "your-unique-bucket-name"
  #
  # Name of the folder you want to delete
  # folder_name = "name-of-the-folder"

  require "google/cloud/storage/control"

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

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

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

  storage_control.delete_folder request

  puts "Deleted folder: #{folder_name}"
end

APIs REST

API JSON

Tener instalada e inicializada la CLI de gcloud, que te permite generar un token de acceso para el encabezado Authorization.

Usa cURL para llamar a la API JSON con una solicitud de DELETE carpeta:
```
curl -X DELETE -H "Authorization: Bearer $(gcloud auth print-access-token)" \
"https://storage.googleapis.com/storage/v1/b/BUCKET_NAME/folders/FOLDER_NAME"
```
Donde:
- BUCKET_NAME es el nombre del segmento que contiene la carpeta que quieres eliminar. Por ejemplo, my-bucket.
- FOLDER_NAME es el nombre codificado en URL de la carpeta que quieres eliminar. Por ejemplo, my-folder/, codificado como URL my-folder%2F.

Obtener los metadatos de una carpeta

En esta sección se describe cómo obtener los metadatos de una carpeta.

Roles necesarios

Para obtener los permisos necesarios para consultar los metadatos de una carpeta, pide a tu administrador que te conceda el rol de gestión de identidades y accesos Lector de objetos de Storage (roles/storage.objectViewer) en el segmento. Este rol contiene el permiso storage.folders.get, que es necesario para obtener los metadatos de una carpeta.

Para obtener instrucciones sobre cómo conceder roles en los contenedores, consulta el artículo Usar gestión de identidades y accesos con contenedores.

También puedes obtener este permiso con otros roles personalizados o roles predefinidos. Si quieres un rol más permisivo que te permita gestionar carpetas además de obtener los metadatos de una carpeta, pide a tu administrador que te conceda uno de los siguientes roles:

Administrador de carpetas de almacenamiento (roles/storage.folderAdmin)
Administrador de objetos de Storage (roles/storage.objectAdmin)
Usuario de objetos de Storage (roles/storage.objectUser)
Administrador de almacenamiento (roles/storage.admin)

Para ver qué roles están asociados a qué permisos, consulta Roles de gestión de identidades y accesos de Cloud Storage.

Línea de comandos

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

gcloud storage folders describe gs://BUCKET_NAME/FOLDER_NAME

Donde:

BUCKET_NAME es el nombre del segmento que contiene la carpeta cuyos metadatos quieres obtener. Por ejemplo, my-bucket.
FOLDER_NAME es el nombre de la carpeta cuyos metadatos quieres obtener. Por ejemplo, my-folder/.

Bibliotecas de cliente

C++

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

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

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

C#

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

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

public class StorageControlGetFolderSample
{
    public Folder StorageControlGetFolder(string bucketName = "your-unique-bucket-name",
        string folderName = "your_folder_name")
    {
        StorageControlClient storageControl = StorageControlClient.Create();

        string folderResourceName =
            // Set project to "_" to signify globally scoped bucket
            FolderName.FormatProjectBucketFolder("_", bucketName, folderName);

        Folder folder = storageControl.GetFolder(folderResourceName);

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

Go

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

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

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

// getFolder gets metadata for the folder with the given name.
func getFolder(w io.Writer, bucket, folder string) error {
	// bucket := "bucket-name"
	// folder := "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/folders/%v", bucket, folder)

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

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

Java

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


import com.google.storage.control.v2.Folder;
import com.google.storage.control.v2.FolderName;
import com.google.storage.control.v2.GetFolderRequest;
import com.google.storage.control.v2.StorageControlClient;
import java.io.IOException;

public final class GetFolder {

  public static void getFolder(String bucketName, String folderName) throws IOException {
    // The name of the bucket
    // String bucketName = "your-unique-bucket-name";

    // The name of the folder within the bucket
    // String folderName = "your-unique-folder-name";

    try (StorageControlClient storageControl = StorageControlClient.create()) {

      GetFolderRequest request =
          GetFolderRequest.newBuilder()
              // Set project to "_" to signify globally scoped bucket
              .setName(FolderName.format("_", bucketName, folderName))
              .build();

      Folder newFolder = storageControl.getFolder(request);

      System.out.printf("Got folder: %s%n", newFolder.getName());
    }
  }
}

Node.js

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

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

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

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

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

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

async function callGetFolder() {
  const folderPath = controlClient.folderPath('_', bucketName, folderName);

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

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

callGetFolder();

PHP

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

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

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

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

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

    $folder = $storageControlClient->getFolder($request);

    printf($folder->getName());
}

Python

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

from google.cloud import storage_control_v2


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

    # The name of the folder
    # folder_name = "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.folder_path(
        project="_", bucket=bucket_name, folder=folder_name
    )

    request = storage_control_v2.GetFolderRequest(
        name=folder_path,
    )
    response = storage_control_client.get_folder(request=request)

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

Ruby

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

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

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

  require "google/cloud/storage/control"

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

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

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

  response = storage_control.get_folder request

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

APIs REST

API JSON

Tener instalada e inicializada la CLI de gcloud, que te permite generar un token de acceso para el encabezado Authorization.

Usa cURL para llamar a la API JSON con una solicitud GET Folder:
```
curl -X GET -H "Authorization: Bearer $(gcloud auth print-access-token)" \
"https://storage.googleapis.com/storage/v1/b/BUCKET_NAME/folders/FOLDER_NAME"
```
Donde:
- BUCKET_NAME es el nombre del segmento que contiene la carpeta de la que quieres obtener los metadatos. Por ejemplo, my-bucket.
- FOLDER_NAME es el nombre codificado como URL de la carpeta cuyos metadatos quieres obtener. Por ejemplo, my-folder/, codificado como URL my-folder%2F.

Gestionar el acceso a una carpeta

En esta sección se describe cómo gestionar el acceso a una carpeta configurando políticas de gestión de identidades y accesos (IAM) para obtener un control de acceso pormenorizado a grupos específicos de objetos de un segmento.

Para gestionar el acceso a tu carpeta, sigue estos pasos:

Habilita la gestión en tu carpeta creando una carpeta gestionada con el mismo nombre que la carpeta que ya tienes. Para obtener instrucciones detalladas, consulta el artículo Crear una carpeta gestionada.
Define y gestiona las políticas de gestión de identidades y accesos (IAM) de la carpeta gestionada que has creado.

Siguientes pasos

Pruébalo

Si es la primera vez que utilizas Google Cloud, crea una cuenta para evaluar el rendimiento de Cloud Storage en situaciones reales. Los nuevos clientes también reciben 300 USD en crédito gratuito para ejecutar, probar y desplegar cargas de trabajo.

Probar Cloud Storage gratis

Crear y gestionar carpetas Organízate con las colecciones Guarda y clasifica el contenido según tus preferencias.

Antes de empezar

Crear una carpeta

Roles necesarios

Consola

Línea de comandos

Bibliotecas de cliente

C++

C#

Go

Java

Node.js

PHP

Python

Ruby

APIs REST

API JSON

Mostrar carpetas

Roles necesarios

Consola

Línea de comandos

Bibliotecas de cliente

C++

C#

Go

Java

Node.js

PHP

Python

Ruby

APIs REST

API JSON

Subir una carpeta

Roles necesarios

Consola

Línea de comandos

Eliminar una carpeta

Roles necesarios

Consola

Línea de comandos

Bibliotecas de cliente

C++

C#

Go

Java

Node.js

PHP

Python

Ruby

APIs REST

API JSON

Obtener los metadatos de una carpeta

Roles necesarios

Línea de comandos

Bibliotecas de cliente

C++

C#

Go

Java

Node.js

PHP

Python

Ruby

APIs REST

API JSON

Gestionar el acceso a una carpeta

Siguientes pasos

Pruébalo

Crear y gestionar carpetas