Diese Seite wurde von der Cloud Translation API übersetzt.

Verwaltete Ordner erstellen und verwalten

In dieser Anleitung erfahren Sie, wie Sie verwaltete Ordner erstellen, auflisten und löschen.

Hinweise

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 löschen Sie verwaltete Ordner: storage.managedFolders.delete

Informationen zum Zuweisen von Rollen für Buckets finden Sie unter IAM mit Buckets verwenden.

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:

Wechseln Sie in der Cloud Console zur Seite Cloud Storage-Buckets.

Buckets aufrufen
Klicken Sie in der Liste der Buckets auf den Namen des Buckets, in dem Sie verwaltete Ordner erstellen möchten.
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.
Geben Sie im Feld Name einen Namen für Ihren Ordner ein. Hinweise zur Benennung finden Sie unter Namen verwalteter Ordner.
Klicken Sie auf Erstellen.

Der neu erstellte Ordner wird im Bereich Ordnerbrowser angezeigt.
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.
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 eine lokale Entwicklungsumgebung 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.

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;
    }
}

Java

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


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.

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

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.

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.

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

REST APIs

JSON API

Installieren und initialisieren Sie die dcloud CLI, um ein Zugriffstoken für den Header Authorization zu generieren.

Alternativ können Sie mit dem OAuth 2.0 Playground ein Zugriffstoken erstellen und in den Header Authorization einfügen.
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.googleapis.com/storage/v1/b/BUCKET_NAME/managedFolders"
```
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/

Verwaltete Ordner auflisten

Console

Wechseln Sie in der Cloud Console zur Seite Cloud Storage-Buckets.

Buckets aufrufen
Maximieren Sie im Bereich Ordnerbrowser die Ein-/Aus-Schaltfläche , 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.

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.

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;
    }
}

Java

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


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.

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

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.

from google.cloud import storage_control_v2


def list_managed_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.ListManagedFoldersRequest(
        parent=bucket_path,
    )

    page_result = storage_control_client.list_managed_folders(request=request)
    for managed_folder in page_result:
        print(managed_folder)

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

Ruby

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

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

REST APIs

JSON API

Installieren und initialisieren Sie die dcloud CLI, um ein Zugriffstoken für den Header Authorization zu generieren.

Alternativ können Sie mit dem OAuth 2.0 Playground ein Zugriffstoken erstellen und in den Header Authorization einfügen.
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.googleapis.com/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.

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.

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;
    }
}

Java

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


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.

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

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.

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.

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

REST APIs

JSON API

Installieren und initialisieren Sie die dcloud CLI, um ein Zugriffstoken für den Header Authorization zu generieren.

Alternativ können Sie mit dem OAuth 2.0 Playground ein Zugriffstoken erstellen und in den Header Authorization einfügen.
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.googleapis.com/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

Erstellen Sie einen neuen verwalteten Ordner im Ziel-Bucket.
Kopieren Sie die IAM-Richtlinien aus dem ursprünglichen verwalteten Ordner im Quell-Bucket in den neuen verwalteten Ordner im Ziel-Bucket.
Kopieren Sie die Objekte aus dem ursprünglichen verwalteten Ordner im Quell-Bucket in den neuen verwalteten Ordner im Ziel-Bucket.
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:

Erstellen Sie einen neuen verwalteten Ordner im Ziel-Bucket.
Kopieren Sie die IAM-Richtlinien aus dem ursprünglichen verwalteten Ordner im Quell-Bucket in den neuen verwalteten Ordner im Ziel-Bucket.
Kopieren Sie die Objekte aus dem ursprünglichen verwalteten Ordner im Quell-Bucket in den neuen verwalteten Ordner im Ziel-Bucket.
Löschen Sie den ursprünglichen verwalteten Ordner aus dem Quell-Bucket.

Verwalteten Ordner löschen

Console

Wechseln Sie in der Cloud Console zur Seite Cloud Storage-Buckets.

Buckets aufrufen
Klicken Sie in der Liste der Buckets auf den Namen des Buckets, der den verwalteten Ordner enthält, den Sie löschen möchten.
Klicken Sie auf der Seite Bucket-Details neben dem verwalteten Ordner, den Sie löschen möchten, auf das Symbol Weitere Optionen .
Klicken Sie auf Ordner löschen.
Geben Sie in das Feld Löschen DELETE ein, um zu bestätigen, dass Sie den verwalteten Ordner löschen möchten.
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.

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.

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

Java

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

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.

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

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.

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.

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

REST APIs

JSON API

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

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

Alternativ können Sie mit dem OAuth 2.0 Playground ein Zugriffstoken erstellen und in den Header Authorization einfügen.
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.googleapis.com/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.

Verwaltete Ordner erstellen und verwalten

Hinweise

Einheitlichen Zugriff auf Bucket-Ebene aktivieren

Erforderliche Rollen abrufen

Erforderliche Berechtigungen

Verwalteten Ordner erstellen

Console

Befehlszeile

Clientbibliotheken

C++

C#

Java

Node.js

PHP

Python

Ruby

REST APIs

JSON API

Verwaltete Ordner auflisten

Console

Befehlszeile

Clientbibliotheken

C++

C#

Java

Node.js

PHP

Python

Ruby

REST APIs

JSON API

Metadaten eines verwalteten Ordners abrufen

Befehlszeile

Clientbibliotheken

C++

C#

Java

Node.js

PHP

Python

Ruby

REST APIs

JSON API

Verwalteten Ordner verschieben

Console

Befehlszeile

REST APIs

JSON API

Verwalteten Ordner löschen

Console

Befehlszeile

Clientbibliotheken

C++

C#

Java

Node.js

PHP

Python

Ruby

REST APIs

JSON API

Fehlerbehebung

Nächste Schritte