Verwaltete Ordner erstellen und verwalten

In diesem Dokument wird beschrieben, wie Sie verwaltete Ordner erstellen, auflisten, abrufen, aktualisieren und löschen.

Mit verwalteten Ordnern können Sie den Zugriff auf Gruppen von Objekten in Ihren Cloud Storage-Buckets steuern, indem Sie IAM-Richtlinien selektiv auf Objekte anwenden, die einen gemeinsamen Präfix in ihren Objektnamenpfaden haben. Dieser Ansatz hilft Ihnen, die Anforderungen an Datensicherheit und Compliance zu erfüllen.

Verwaltete Ordner können auch verwendet werden, um Rapid Cache-Caches zu aktivieren, damit Daten beim Schreiben selektiv nach Objektnamenspräfix aufgenommen werden. Weitere Informationen finden Sie unter Ingest-on-write.

Hinweis

Wenn Sie verwaltete Ordner erstellen und verwalten möchten, müssen Sie zuerst den einheitlichen Zugriff auf Bucket-Ebene aktivieren und die erforderlichen IAM-Rollen erhalten.

Einheitlichen Zugriff auf Bucket-Ebene aktivieren

Falls noch nicht geschehen, aktivieren Sie den einheitlichen Zugriff auf Bucket-Ebene.

Erforderliche Rollen abrufen

Bitten Sie Ihren Administrator, Ihnen die IAM-Rolle Storage Folder Admin (roles/storage.folderAdmin) für den Bucket zuzuweisen, um die Berechtigungen zu erhalten, die Sie zum Erstellen und Verwalten von verwalteten Ordnern benötigen.

Diese vordefinierte Rolle enthält die Berechtigungen, die zum Erstellen und Verwalten von verwalteten Ordnern erforderlich sind. Erweitern Sie den Abschnitt Erforderliche Berechtigungen, um die erforderlichen Berechtigungen anzuzeigen:

Erforderliche Berechtigungen

Die folgenden Berechtigungen sind erforderlich, um verwaltete Ordner zu erstellen und zu verwalten:

  • So erstellen Sie verwaltete Ordner: storage.managedFolders.create
  • So validieren Sie neu erstellte verwaltete Ordner, indem Sie sie auflisten: storage.objects.list
  • So listen Sie verwaltete Ordner auf: storage.managedFolders.list
  • So rufen Sie verwaltete Ordner ab: storage.managedFolders.get
  • So verschieben Sie verwaltete Ordner:
    • storage.managedFolders.delete (für den Quell-Bucket)
    • storage.managedFolders.create (für den Ziel-Bucket)
  • So aktualisieren Sie verwaltete Ordner: storage.managedFolders.update
  • So löschen Sie verwaltete Ordner: storage.managedFolders.delete

Informationen zum Zuweisen von Rollen für Buckets finden Sie unter IAM-Richtlinien für Buckets festlegen und verwalten.

Verwalteten Ordner erstellen

Console

Wenn Sie die Google Cloud Console verwenden, erstellen Sie verwaltete Ordner, indem Sie die Verwaltung für Ordner oder simulierte Ordner aktivieren. In den folgenden Schritten wird beschrieben, wie Sie einen Ordner oder einen simulierten Ordner erstellen und dann die Ordnerverwaltung aktivieren:

  1. Wechseln Sie in der Google Cloud Console unter „Cloud Storage“ zur Seite Buckets.

    Buckets aufrufen

  2. Klicken Sie in der Liste der Buckets auf den Namen des Buckets, in dem Sie verwaltete Ordner erstellen möchten.

  3. Klicken Sie auf der Seite Bucket-Details auf Ordner erstellen, um einen neuen Ordner zu erstellen. Wenn der Ordner, den Sie in einen verwalteten Ordner konvertieren möchten, bereits vorhanden ist, fahren Sie mit dem Schritt fort, in dem beschrieben wird, wie Sie das Menü Weitere Optionen aufrufen.

  4. Geben Sie im Feld Name einen Namen für Ihren Ordner ein. Hinweise zur Benennung finden Sie unter Namen verwalteter Ordner.

  5. Klicken Sie auf Erstellen.

    Der neu erstellte Ordner wird im Bereich Ordnerbrowser angezeigt.

  6. Klicken Sie im Bereich Ordnerbrowser auf das Menü Weitere Optionen neben dem Ordner, den Sie in einen verwalteten Ordner konvertieren möchten, und klicken Sie dann auf Zugriff bearbeiten.

    Das Dialogfeld Ordnerverwaltung aktivieren? wird angezeigt.

  7. Klicken Sie auf Aktivieren.

    Der Ordner wird in einen verwalteten Ordner konvertiert. Im Bereich Berechtigungen für MANAGED_FOLDER_NAME werden die IAM-Richtlinien für den Ordner nach Hauptkonto und Rolle angezeigt. Informationen zum Erstellen neuer IAM-Richtlinien finden Sie unter IAM-Richtlinie für einen verwalteten Ordner festlegen.

Befehlszeile

Führen Sie den gcloud storage managed-folders create-Befehl aus, um einen verwalteten Ordner zu erstellen:

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

Dabei gilt:

  • BUCKET_NAME ist der Name des Buckets, in dem Sie einen verwalteten Ordner erstellen möchten. Beispiel: my-bucket.

  • MANAGED_FOLDER_NAME ist der Name des verwalteten Ordners, den Sie erstellen möchten. Beispiel: my-managed-folder/.

Führen Sie den Befehl gcloud storage managed-folders describe aus, um zu prüfen, ob der verwaltete Ordner erstellt wurde:

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

Dabei gilt:

  • BUCKET_NAME ist der Name des Buckets, in dem Sie einen verwalteten Ordner erstellt haben.

  • MANAGED_FOLDER_NAME ist der Name des verwalteten Ordners, den Sie erstellt haben.

Clientbibliotheken

C++

Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Storage C++ API.

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Cloud Storage zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten. 

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#

Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Storage C# API.

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Cloud Storage zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten. 

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

Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Storage Go API.

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Cloud Storage zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten. 

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

Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Storage Java API.

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Cloud Storage zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten. 


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

Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Storage Node.js API.

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Cloud Storage zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten. 

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

Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Storage PHP API.

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Cloud Storage zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten. 

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

Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Storage Python API.

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Cloud Storage zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten. 

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

Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Storage Ruby API.

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Cloud Storage zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten. 

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(())
}

REST APIs

JSON-API

  1. Die gcloud CLI installieren und initialisieren, um ein Zugriffstoken für den Authorization-Header zu generieren.

  2. Verwenden Sie cURL, um die JSON API mit einer POST-ManagedFolder-Anfrage aufzurufen:

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

    Wobei:

    • MANAGED_FOLDER_NAME ist der Name des verwalteten Ordners, den Sie erstellen möchten. Beispiel: my-managed-folder/

    • BUCKET_NAME ist der Name des Buckets, in dem Sie einen verwalteten Ordner erstellen möchten. Beispiel: my-bucket

    Verwalteten Ordner erstellen, um die Ingest-on-Write-Funktion von Rapid Cache zu aktivieren

    In diesem Abschnitt wird beschrieben, wie Sie einen verwalteten Ordner mit Einstellungen erstellen, die das Feature „Rapid Cache ingest-on-write“ auf Präfixebene aktivieren. Wenn Sie Rapid Cache oder die Funktion „Ingest-on-Write“ nicht verwenden, überspringen Sie diesen Abschnitt.

    So erstellen Sie einen verwalteten Ordner, um prefix-level ingest on write für Caches zu aktivieren, die mit Rapid Cache erstellt wurden:

    1. Informationen zum Aktivieren von „Ingest-on-Write“

    2. Achten Sie darauf, dass die ingestOnWrite-Property des Cache auf false gesetzt ist. Eine Anleitung finden Sie unter Cache aktualisieren.

    3. Fügen Sie Ihrer Anfrage eine rapidCacheConfig-Konfiguration hinzu:

    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"

    Wobei:

    • MANAGED_FOLDER_NAME ist der Name des verwalteten Ordners, den Sie erstellen möchten. Der Cache verwendet diesen Namen des verwalteten Ordners, um Objekte beim Schreiben selektiv aufzunehmen. Wenn Sie beispielsweise my-managed-folder/ als Namen des verwalteten Ordners angeben, werden im Cache nur Objekte im Bucket aufgenommen, deren Name my-managed-folder/ im Pfad enthält.

    • RAPID_CACHE_ID ist die Kennung für den Cache, also die Zone des Cache. Beispiel: us-east1-b. Der von Ihnen angegebene Cache muss mit dem Bucket verknüpft sein, in dem der verwaltete Ordner erstellt wird. Wenn Sie die mit einem Bucket verknüpften Caches aufrufen möchten, listen Sie die Caches für den Bucket auf.

    • BUCKET_NAME ist der Name des Buckets, der dem Cache zugeordnet ist. Beispiel: my-cached-bucket. Der verwaltete Ordner wird in diesem Bucket erstellt.

Verwaltete Ordner auflisten

Console

  1. Wechseln Sie in der Google Cloud Console unter „Cloud Storage“ zur Seite Buckets.

    Buckets aufrufen

  2. Maximieren Sie im Bereich Ordnerbrowser den Ein-/Aus-Button , um die Liste der Ordner in dem Bucket zu maximieren.

In einer Liste werden die Ordner, simulierten Ordner und verwalteten Ordner in Ihrem Bucket angezeigt.

Befehlszeile

Führen Sie den Befehl gcloud storage managed-folders list aus, um verwaltete Ordner aufzulisten:

gcloud storage managed-folders list gs://BUCKET_NAME

Dabei gilt:

  • BUCKET_NAME ist der Name des Buckets, der die verwalteten Ordner enthält, die Sie auflisten möchten. Beispiel: my-bucket.

Sie können auch einen Ordnerpfad anstelle eines Bucket-Namens angeben. Beispiel:

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

Clientbibliotheken

C++

Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Storage C++ API.

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Cloud Storage zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten. 

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#

Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Storage C# API.

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Cloud Storage zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten. 

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

Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Storage Go API.

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Cloud Storage zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten. 

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

Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Storage Java API.

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Cloud Storage zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten. 


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

Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Storage Node.js API.

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Cloud Storage zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten. 

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

Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Storage PHP API.

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Cloud Storage zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten. 

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

Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Storage Python API.

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Cloud Storage zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten. 

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

Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Storage Ruby API.

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Cloud Storage zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten. 

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(())
}

REST APIs

JSON-API

  1. Die gcloud CLI installieren und initialisieren, um ein Zugriffstoken für den Authorization-Header zu generieren.

  2. Verwenden Sie cURL, um die JSON API mit einer Anfrage zum Auflisten verwalteter Ordner aufzurufen:

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

    Dabei ist BUCKET_NAME der Name des Buckets, der die verwalteten Ordner enthält, die Sie auflisten möchten. Beispiel: my-bucket

Metadaten eines verwalteten Ordners abrufen

Befehlszeile

Führen Sie den Befehl gcloud storage managed-folders describe aus, um die Metadaten eines verwalteten Ordners abzurufen:

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

Dabei gilt:

  • BUCKET_NAME ist der Name des Buckets, der die verwalteten Ordner enthält, die Sie auflisten möchten. Beispiel: my-bucket.

  • MANAGED_FOLDER_NAME ist der Name des verwalteten Ordners, für den Sie Metadaten abrufen möchten.

Clientbibliotheken

C++

Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Storage C++ API.

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Cloud Storage zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten. 

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#

Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Storage C# API.

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Cloud Storage zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten. 

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

Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Storage Go API.

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Cloud Storage zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten. 

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

Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Storage Java API.

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Cloud Storage zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten. 


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

Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Storage Node.js API.

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Cloud Storage zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten. 

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

Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Storage PHP API.

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Cloud Storage zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten. 

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

Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Storage Python API.

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Cloud Storage zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten. 

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

Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Storage Ruby API.

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Cloud Storage zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten. 

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(())
}

REST APIs

JSON-API

  1. Die gcloud CLI installieren und initialisieren, um ein Zugriffstoken für den Authorization-Header zu generieren.

  2. Verwenden Sie cURL, um die JSON API mit einer Anfrage zum Abrufen verwalteter Ordner aufzurufen:

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

    Dabei gilt:

    • BUCKET_NAME ist der Name des Buckets, der die verwalteten Ordner enthält, die Sie aufrufen möchten. Beispiel: my-bucket

    • MANAGED_FOLDER_NAME ist der Name des verwalteten Ordners, ausgedrückt als Pfad. Beispiel: example-dir/ Wenn der verwaltete Ordner verschachtelt ist, muss das Schrägstrichzeichen (/) im Pfad des verwalteten Ordners mit einem Escapezeichen versehen werden. Beispiel: example-dir1%2Fexample-dir2.

Verwalteten Ordner verschieben

Console

  1. Erstellen Sie einen neuen verwalteten Ordner im Ziel-Bucket.

  2. Kopieren Sie die IAM-Richtlinien aus dem ursprünglichen verwalteten Ordner im Quell-Bucket in den neuen verwalteten Ordner im Ziel-Bucket.

  3. Kopieren Sie die Objekte aus dem ursprünglichen verwalteten Ordner im Quell-Bucket in den neuen verwalteten Ordner im Ziel-Bucket.

  4. Löschen Sie den ursprünglichen verwalteten Ordner aus dem Quell-Bucket.

Befehlszeile

Führen Sie den Befehl gcloud storage mv mit der Option --include-managed-folders aus, um verwaltete Ordner und die darin enthaltenen Objekte zu verschieben:

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

Dabei gilt:

  • SOURCE_BUCKET ist der Name des ursprünglichen Buckets. Zum Beispiel, my-source-bucket.

  • DESTINATION_BUCKET ist der Name des Buckets, in den Sie den verwalteten Ordner verschieben. Beispiel: my-destination-bucket

  • MANAGED_FOLDER_NAME ist der Name des verwalteten Ordners, den Sie verschieben. Beispiel: my-managed-folder/.

REST APIs

JSON API

So verschieben Sie verwaltete Ordner von einem Bucket in einen anderen:

  1. Erstellen Sie einen neuen verwalteten Ordner im Ziel-Bucket.

  2. Kopieren Sie die IAM-Richtlinien aus dem ursprünglichen verwalteten Ordner im Quell-Bucket in den neuen verwalteten Ordner im Ziel-Bucket.

  3. Kopieren Sie die Objekte aus dem ursprünglichen verwalteten Ordner im Quell-Bucket in den neuen verwalteten Ordner im Ziel-Bucket.

  4. Löschen Sie den ursprünglichen verwalteten Ordner aus dem Quell-Bucket.

Richtlinie für die Aufnahme bei Schreibvorgängen für den Rapid Cache-Dienst für einen verwalteten Ordner aktualisieren

In diesem Abschnitt wird beschrieben, wie Sie die Einstellung „Rapid Cache Ingest-on-Write“ auf Präfixebene aktivieren oder deaktivieren. Dabei werden verwaltete Ordner als zugrunde liegender Mechanismus verwendet. Wenn Sie Rapid Cache oder die Funktion „Ingest-on-Write“ nicht verwenden, überspringen Sie diesen Abschnitt.

Wenn Sie die Richtlinie zum Erfassen beim Schreiben für Rapid Cache für Objekte aktivieren oder deaktivieren möchten, die ein gemeinsames Präfix für verwaltete Ordner haben, müssen Sie die rapidCacheConfig-Konfiguration des verwalteten Ordners aktualisieren. Diese Anleitung ist nur erforderlich, wenn Sie die JSON API verwenden, um die Ingest-on-Write-Richtlinie eines Cache zu aktualisieren.

Weitere Informationen zum Aktivieren oder Deaktivieren von „Ingest-on-Write“ auf Präfixebene finden Sie unter „Ingest-on-Write“.

REST APIs

JSON API

So fügen Sie die Richtlinie „Rapid Cache ingest-on-write“ für einen verwalteten Ordner hinzu, ändern oder löschen sie:

  1. Achten Sie darauf, dass Sie die Property ingestOnWrite in der Konfiguration des Cache festgelegt haben. Informationen dazu, welchen Wert Sie für das Attribut festlegen sollten, finden Sie unter Ingest-on-Write.

  2. Verwenden Sie cURL, um die JSON API mit einer PATCH-ManagedFolder-Anfrage aufzurufen. Der Anfragetext unterscheidet sich je nach Anwendungsfall:

    Richtlinie „Ingest on Write“ für einen verwalteten Ordner aktivieren oder deaktivieren

    Verwenden Sie den folgenden Befehl, um die Konfiguration für die Aufnahme beim Schreiben für einen oder mehrere Caches zu aktualisieren:

    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"

    Ersetzen Sie:

    • BUCKET_NAME: der Name des Buckets, der den verwalteten Ordner enthält.

    • MANAGED_FOLDER_NAME: mit dem Namen des verwalteten Ordners.

    • RAPID_CACHE_ID: mit der Kennung für den Cache, also der Zone des Cache. Beispiel: us-east1-b.

    • INGEST_VALUE: mit dem Ingestion-Verhalten des Cache. Wenn der Wert enabled ist, ist „Ingest-on-Write“ für verwaltete Ordnerpräfixe aktiviert. Wenn der Wert unspecified ist, wird das Verhalten des Caches beim Schreiben entweder von einem übergeordneten verwalteten Ordner (falls vorhanden) oder von der Cachekonfiguration im Bucket übernommen. Weitere Informationen zu den durch diese Werte festgelegten Verhaltensweisen finden Sie unter Anforderungen für die Aufnahme beim Schreiben. Lesen Sie sich die Informationen zur Übernahme beim Schreiben sorgfältig durch, um zu verstehen, wie sich die Richtlinie zur Übernahme beim Schreiben eines Caches auswirken kann, wenn die ingestOnWrite-Einstellung für den Cache auf unspecified festgelegt ist.

    Wenn Sie die Aufnahme bei Schreibvorgängen für mehrere Caches gleichzeitig konfigurieren möchten, fügen Sie Ihrer Anfrage mehrere policies-Maps hinzu. Beispiel:

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

    Wenn Sie die Aufnahme auf Präfixebene beim Schreiben für einzelne Caches deaktivieren möchten, entfernen Sie die policies-Zuordnung für den Cache aus der rapidCacheConfig-Konfiguration.

    „Ingest-on-Write“-Richtlinie für einen verwalteten Ordner löschen

    Sie können die Ingest-on-Write-Richtlinie für einen verwalteten Ordner mithilfe der Anleitung in diesem Abschnitt löschen. Wenn Sie die Ingest-on-Write-Richtlinie für einen verwalteten Ordner löschen, werden die in Ihrer Anfrage angegebenen Caches keine Objekte mehr nach dem Präfix des verwalteten Ordners aufnehmen. Das Aufnahmeverhalten für Objekte im Bucket wird durch das Feld ingestOnWrite der Cachekonfiguration bestimmt. Informationen dazu, wie das Verhalten beim Ingest-on-Write durch das Feld ingestOnWrite eines verwalteten Ordners im Vergleich zu einer Cachekonfiguration bestimmt wird, finden Sie unter Ingest-on-Write aktivieren und Ingest-on-Write-Vererbung.

    Verwenden Sie den folgenden Befehl, um die Ingest-on-Write-Richtlinie für einen verwalteten Ordner zu löschen. Mit dem folgenden Befehl wird die Aufnahme beim Schreiben auf Präfixebene für einzelne Caches für die verwaltete Ordnerressource deaktiviert, die diese Konfiguration enthält:

    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"

    Ersetzen Sie:

    • BUCKET_NAME: der Name des Buckets, der den verwalteten Ordner enthält.

    • MANAGED_FOLDER_NAME: mit dem Namen des verwalteten Ordners.

    • RAPID_CACHE_ID: mit der Kennung für den Cache, also der Zone des Cache. Beispiel: us-east1-b. Dieses Feld muss auf null gesetzt sein.

    Alternativ können Sie die Ingest-on-Write-Richtlinie auf Präfixebene für einen verwalteten Ordner löschen, indem Sie die policies-Zuordnung in Ihrer Anfrage auf null festlegen:

    "rapidCacheConfig": {
"policies": null
}

Verwalteten Ordner löschen

Console

  1. Wechseln Sie in der Google Cloud Console unter „Cloud Storage“ zur Seite Buckets.

    Buckets aufrufen

  2. Klicken Sie in der Liste der Buckets auf den Namen des Buckets, der den verwalteten Ordner enthält, den Sie löschen möchten.

  3. Klicken Sie auf der Seite Bucket-Details neben dem verwalteten Ordner, den Sie löschen möchten, auf das Symbol Weitere Optionen .

  4. Klicken Sie auf Ordner löschen.

  5. Geben Sie in das Feld Löschen DELETE ein, um zu bestätigen, dass Sie den verwalteten Ordner löschen möchten.

  6. Klicken Sie auf Löschen.

    Der verwaltete Ordner und sein Inhalt, einschließlich gespeicherter Objekte und anderer verwalteter Ordner, werden aus dem Cloud Storage-Bucket gelöscht.

Befehlszeile

Führen Sie den Befehl gcloud storage rm aus, um einen verwalteten Ordner und die darin enthaltenen Objekte zu löschen:

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

Dabei gilt:

  • BUCKET_NAME ist der Name des Buckets, der den verwalteten Ordner enthält, den Sie löschen möchten. Beispiel: my-bucket.

  • MANAGED_FOLDER_NAME ist der Name des verwalteten Ordners, den Sie löschen möchten. Beispiel: my-managed-folder/.

Clientbibliotheken

C++

Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Storage C++ API.

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Cloud Storage zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten. 

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#

Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Storage C# API.

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Cloud Storage zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten. 

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

Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Storage Go API.

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Cloud Storage zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten. 

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

Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Storage Java API.

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Cloud Storage zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten. 

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

Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Storage Node.js API.

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Cloud Storage zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten. 

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

Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Storage PHP API.

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Cloud Storage zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten. 

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

Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Storage Python API.

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Cloud Storage zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten. 

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

Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Storage Ruby API.

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Cloud Storage zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten. 

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(())
}

REST APIs

JSON API

Sie müssen zuerst die Objekte im verwalteten Ordner löschen, um einen verwalteten Ordner zu löschen.

  1. Die gcloud CLI installieren und initialisieren, um ein Zugriffstoken für den Authorization-Header zu generieren.

  2. Verwenden Sie cURL, um die JSON API mit einer DELETE-ManagedFolder-Anfrage aufzurufen:

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

    Dabei gilt:

    • BUCKET_NAME ist der Name des Buckets, der den verwalteten Ordner enthält, den Sie löschen möchten. Beispiel: my-bucket

    • MANAGED_FOLDER_NAME ist der Name des verwalteten Ordners, den Sie löschen möchten. Beispiel: my-managed-folder/.

    Standardmäßig müssen verwaltete Ordner leer sein, bevor sie gelöscht werden können. Wenn Sie einen nicht leeren verwalteten Ordner löschen möchten, fügen Sie allowNonEmpty=true als Abfrageparameter in Ihre Anfrage ein.

Fehlerbehebung

Informationen zum Erstellen und Verwalten von verwalteten Ordnern finden Sie auf der Seite zur Fehlerbehebung.

Nächste Schritte