יצירה וניהול של תיקיות מנוהלות

במאמר הזה מוסבר איך ליצור, להציג, לקבל, לעדכן ולמחוק תיקיות מנוהלות.

תיקיות מנוהלות מאפשרות לכם לשלוט בגישה לקבוצות של אובייקטים בקטגוריות של Cloud Storage, על ידי הגדרה סלקטיבית של כללי מדיניות IAM לאובייקטים שיש להם קידומת משותפת בנתיבי השמות שלהם. הגישה הזו עוזרת לעמוד בדרישות של אבטחת מידע ותאימות.

אפשר להשתמש בתיקיות מנוהלות גם כדי לאפשר למטמונים של Rapid Cache להטמיע נתונים בכתיבה באופן סלקטיבי לפי קידומת שם האובייקט. מידע נוסף זמין במאמר הטמעה בזמן כתיבה.

לפני שמתחילים

כדי ליצור ולנהל תיקיות מנוהלות, צריך קודם להפעיל גישה אחידה ברמת הקטגוריה ולקבל את תפקידי ה-IAM הנדרשים.

הפעלת גישה אחידה ברמת הקטגוריה

אם עדיין לא עשיתם את זה, הפעילו גישה אחידה ברמת הקטגוריה.

קבלת התפקידים הנדרשים

כדי לקבל את ההרשאות שנדרשות ליצירה ולניהול של תיקיות מנוהלות, צריך לבקש מהאדמין להקצות לכם את התפקיד אדמין של תיקיות אחסון (roles/storage.folderAdmin) ב-IAM בקטגוריה.

זהו תפקיד שמוגדר מראש וכולל את ההרשאות שנדרשות ליצירה ולניהול של תיקיות מנוהלות. כדי לראות בדיוק אילו הרשאות נדרשות, אפשר להרחיב את הקטע ההרשאות הנדרשות:

ההרשאות הנדרשות

כדי ליצור ולנהל תיקיות מנוהלות, נדרשות ההרשאות הבאות:

• כדי ליצור תיקיות מנוהלות: storage.managedFolders.create
• כדי לאמת את התיקיות המנוהלות החדשות שנוצרו, אפשר להציג אותן ברשימה: storage.objects.list
• כדי להציג רשימה של תיקיות מנוהלות: storage.managedFolders.list
• כדי לקבל תיקיות מנוהלות: storage.managedFolders.get
• כדי להעביר תיקיות מנוהלות:
  • ‫storage.managedFolders.delete (בקטגוריית המקור)
  • ‫storage.managedFolders.create (בקטגוריית היעד)
• כדי לעדכן תיקיות מנוהלות: storage.managedFolders.update
• כדי למחוק תיקיות מנוהלות: storage.managedFolders.delete

במאמר הגדרה וניהול של מדיניות IAM בקטגוריות מוסבר איך מקצים תפקידים בקטגוריות.

יצירת תיקייה מנוהלת

המסוף

כשמשתמשים במסוף Google Cloud , יוצרים תיקיות מנוהלות על ידי הפעלת הניהול בתיקיות או בתיקיות מדומות. כך יוצרים תיקייה או תיקייה מדומה ומפעילים את ניהול התיקיות:

1. במסוף Google Cloud , נכנסים לדף Buckets של Cloud Storage.
   

   כניסה לדף Buckets

2. ברשימת הקטגוריות, לוחצים על שם הקטגוריה שבה רוצים ליצור תיקיות מנוהלות.

3. בדף Bucket details, לוחצים על Create folder כדי ליצור תיקייה חדשה. אם התיקייה שרוצים להמיר לתיקייה מנוהלת כבר קיימת, דלגו לשלב שמתאר איך לגשת לתפריט More options .

4. בשדה שם, נותנים שם לתיקייה. לשיקולים בנוגע למתן שמות, ראו שמות של תיקיות מנוהלות.

5. לוחצים על יצירה.

   התיקייה החדשה שיצרתם מופיעה בחלונית דפדפן התיקיות.

6. בחלונית Folder browser, לוחצים על תפריט האפשרויות הנוספות לצד התיקייה שרוצים להמיר לתיקייה מנוהלת, ולוחצים על Edit access.

   מופיעה תיבת הדו-שיח להפעיל את ניהול התיקיות?.

7. לוחצים על Enable.

   התיקייה תהפוך לתיקייה מנוהלת. מופיע החלונית Permissions for MANAGED_FOLDER_NAME, שבה מוצגת מדיניות ה-IAM בתיקייה לפי חשבון משתמש ותפקיד. כדי ליצור מדיניות IAM חדשה, קראו את המאמר הגדרת מדיניות IAM בתיקייה מנוהלת.

שורת הפקודה

כדי ליצור תיקייה מנוהלת, מריצים את הפקודה gcloud storage managed-folders create:

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

כאשר:

• ‫BUCKET_NAME הוא שם הקטגוריה שבה רוצים ליצור תיקייה מנוהלת. לדוגמה, my-bucket.

• ‫MANAGED_FOLDER_NAME הוא השם של התיקייה המנוהלת שרוצים ליצור. לדוגמה, my-managed-folder/.

כדי לוודא שהתיקייה המנוהלת נוצרה, מריצים את הפקודה gcloud storage managed-folders describe:

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

כאשר:

• ‫BUCKET_NAME הוא שם הקטגוריה שבה יצרתם תיקייה מנוהלת.

• ‫MANAGED_FOLDER_NAME הוא שם התיקייה המנוהלת שיצרתם.

ספריות לקוח

C++

למידע נוסף, קראו את מאמרי העזרה של Cloud Storage C++ API.

כדי לבצע אימות ב-Cloud Storage, אתם צריכים להגדיר את Application Default Credentials. מידע נוסף זמין במאמר הגדרת אימות לספריות לקוח.

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#

למידע נוסף, קראו את מאמרי העזרה של Cloud Storage C# API.

כדי לבצע אימות ב-Cloud Storage, אתם צריכים להגדיר את Application Default Credentials. מידע נוסף זמין במאמר הגדרת אימות לספריות לקוח.

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

למידע נוסף, קראו את מאמרי העזרה של Cloud Storage Go API.

כדי לבצע אימות ב-Cloud Storage, אתם צריכים להגדיר את Application Default Credentials. מידע נוסף זמין במאמר הגדרת אימות לספריות לקוח.

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

למידע נוסף, קראו את מאמרי העזרה של Cloud Storage Java API.

כדי לבצע אימות ב-Cloud Storage, אתם צריכים להגדיר את Application Default Credentials. מידע נוסף זמין במאמר הגדרת אימות לספריות לקוח.

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

למידע נוסף, קראו את מאמרי העזרה של Cloud Storage Node.js API.

כדי לבצע אימות ב-Cloud Storage, אתם צריכים להגדיר את Application Default Credentials. מידע נוסף זמין במאמר הגדרת אימות לספריות לקוח.

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

למידע נוסף, קראו את מאמרי העזרה של Cloud Storage PHP API.

כדי לבצע אימות ב-Cloud Storage, אתם צריכים להגדיר את Application Default Credentials. מידע נוסף זמין במאמר הגדרת אימות לספריות לקוח.

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

למידע נוסף, קראו את מאמרי העזרה של Cloud Storage Python API.

כדי לבצע אימות ב-Cloud Storage, אתם צריכים להגדיר את Application Default Credentials. מידע נוסף זמין במאמר הגדרת אימות לספריות לקוח.

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

למידע נוסף, קראו את מאמרי העזרה של Cloud Storage Ruby API.

כדי לבצע אימות ב-Cloud Storage, אתם צריכים להגדיר את Application Default Credentials. מידע נוסף זמין במאמר הגדרת אימות לספריות לקוח.

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

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

  require "google/cloud/storage/control"

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

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

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

  response = storage_control.create_managed_folder request

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

Rust

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

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

ממשקי API בארכיטקטורת REST

‫API בפורמט JSON

1. להתקין ולהפעיל את ה-CLI של gcloud, כדי שתוכלו ליצור אסימון גישה לכותרת Authorization.

2. משתמשים ב-cURL כדי לשלוח קריאה ל-API בפורמט JSON באמצעות בקשת תיקייה מנוהלת של POST:

   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"

   כאשר:

   • ‫MANAGED_FOLDER_NAME הוא השם של התיקייה המנוהלת שרוצים ליצור. לדוגמה, my-managed-folder/.

   • ‫BUCKET_NAME הוא שם הקטגוריה שבה רוצים ליצור תיקייה מנוהלת. לדוגמה, my-bucket.

   יצירת תיקייה מנוהלת כדי להפעיל את Rapid Cache ingest-on-write

   בקטע הזה מוסבר איך ליצור תיקייה מנוהלת עם הגדרות שמפעילות את התכונה "הטמעה בזמן כתיבה" של Rapid Cache ברמת הקידומת. אם אתם לא משתמשים ב-Rapid Cache או בתכונה ingest-on-write, אתם יכולים לדלג על החלק הזה.

   אם רוצים ליצור תיקייה מנוהלת כדי להפעיל הטמעה ברמת הקידומת בזמן הכתיבה למטמונים שנוצרו באמצעות Rapid Cache:

   1. כדי להבין איך מגדירים הטמעה בזמן כתיבה ברמת הקידומת, קראו את המאמר הסבר על הפעלת הטמעה בזמן כתיבה.

   2. מוודאים שהמאפיין ingestOnWrite של המטמון מוגדר כ-false. הוראות מפורטות זמינות במאמר עדכון מטמון.

   3. כוללים הגדרה של rapidCacheConfig בבקשה:

   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.googleapis.com/storage/v1/b/BUCKET_NAME/managedFolders"

   כאשר:

   • ‫MANAGED_FOLDER_NAME הוא השם של התיקייה המנוהלת שרוצים ליצור. השם של התיקייה המנוהלת משמש את המטמון כדי להטמיע אובייקטים באופן סלקטיבי בזמן הכתיבה. לדוגמה, אם מציינים את השם my-managed-folder/ לתיקייה המנוהלת, המטמון יטמיע רק אובייקטים בקטגוריה שהשם שלהם כולל את my-managed-folder/ בנתיב.

   • ‫RAPID_CACHE_ID הוא המזהה של המטמון, שהוא האזור של המטמון. לדוגמה, us-east1-b. המאגר שאתם מציינים חייב להיות משויך לקטגוריה שבה נוצרת התיקייה המנוהלת. כדי למצוא את המטמונים שמשויכים לקטגוריה, מציגים את רשימת המטמונים של הקטגוריה.

   • ‫BUCKET_NAME הוא שם הקטגוריה שמשויכת למטמון. לדוגמה, my-cached-bucket. התיקייה המנוהלת תיווצר בקטגוריה הזו.

הצגת רשימה של תיקיות מנוהלות

המסוף

1. במסוף Google Cloud , נכנסים לדף Buckets של Cloud Storage.
   

   כניסה לדף Buckets

2. בחלונית Folder browser, משתמשים בצומת ההחלפה כדי להרחיב את רשימת התיקיות בקטגוריה.

תוצג רשימה של התיקיות, התיקיות המדומות והתיקיות המנוהלות בקטגוריה.

שורת הפקודה

כדי להציג רשימה של תיקיות מנוהלות, מריצים את הפקודה gcloud storage managed-folders list:

gcloud storage managed-folders list gs://BUCKET_NAME

כאשר:

• ‫BUCKET_NAME הוא שם הקטגוריה שמכילה את התיקיות המנוהלות שרוצים להציג ברשימה. לדוגמה, my-bucket.

שימו לב שאפשר גם לציין נתיב של תיקייה במקום שם של קטגוריה. לדוגמה:

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

ספריות לקוח

C++

למידע נוסף, קראו את מאמרי העזרה של Cloud Storage C++ API.

כדי לבצע אימות ב-Cloud Storage, אתם צריכים להגדיר את Application Default Credentials. מידע נוסף זמין במאמר הגדרת אימות לספריות לקוח.

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#

למידע נוסף, קראו את מאמרי העזרה של Cloud Storage C# API.

כדי לבצע אימות ב-Cloud Storage, אתם צריכים להגדיר את Application Default Credentials. מידע נוסף זמין במאמר הגדרת אימות לספריות לקוח.

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

למידע נוסף, קראו את מאמרי העזרה של Cloud Storage Go API.

כדי לבצע אימות ב-Cloud Storage, אתם צריכים להגדיר את Application Default Credentials. מידע נוסף זמין במאמר הגדרת אימות לספריות לקוח.

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

למידע נוסף, קראו את מאמרי העזרה של Cloud Storage Java API.

כדי לבצע אימות ב-Cloud Storage, אתם צריכים להגדיר את Application Default Credentials. מידע נוסף זמין במאמר הגדרת אימות לספריות לקוח.

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

למידע נוסף, קראו את מאמרי העזרה של Cloud Storage Node.js API.

כדי לבצע אימות ב-Cloud Storage, אתם צריכים להגדיר את Application Default Credentials. מידע נוסף זמין במאמר הגדרת אימות לספריות לקוח.

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

למידע נוסף, קראו את מאמרי העזרה של Cloud Storage PHP API.

כדי לבצע אימות ב-Cloud Storage, אתם צריכים להגדיר את Application Default Credentials. מידע נוסף זמין במאמר הגדרת אימות לספריות לקוח.

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

למידע נוסף, קראו את מאמרי העזרה של Cloud Storage Python API.

כדי לבצע אימות ב-Cloud Storage, אתם צריכים להגדיר את Application Default Credentials. מידע נוסף זמין במאמר הגדרת אימות לספריות לקוח.

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

למידע נוסף, קראו את מאמרי העזרה של Cloud Storage Ruby API.

כדי לבצע אימות ב-Cloud Storage, אתם צריכים להגדיר את Application Default Credentials. מידע נוסף זמין במאמר הגדרת אימות לספריות לקוח.

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

  require "google/cloud/storage/control"

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

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

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

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

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

Rust

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

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

ממשקי API בארכיטקטורת REST

‫API בפורמט JSON

1. להתקין ולהפעיל את ה-CLI של gcloud, כדי שתוכלו ליצור אסימון גישה לכותרת Authorization.

2. משתמשים בפקודה cURL כדי להעביר ל-API בפורמט JSON בקשה לקריאת רשימה של תיקיות מנוהלות:

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

   ‫BUCKET_NAME הוא שם הקטגוריה שמכילה את התיקיות המנוהלות שרוצים להציג ברשימה. לדוגמה, my-bucket.

אחזור המטא-נתונים של תיקייה מנוהלת

שורת הפקודה

כדי לקבל את המטא-נתונים של תיקייה מנוהלת, מריצים את הפקודה gcloud storage managed-folders describe:

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

כאשר:

• ‫BUCKET_NAME הוא שם הקטגוריה שמכילה את התיקיות המנוהלות שרוצים להציג ברשימה. לדוגמה, my-bucket.

• ‫MANAGED_FOLDER_NAME הוא שם התיקייה המנוהלת שרוצים לאחזר את המטא-נתונים שלה.

ספריות לקוח

C++

למידע נוסף, קראו את מאמרי העזרה של Cloud Storage C++ API.

כדי לבצע אימות ב-Cloud Storage, אתם צריכים להגדיר את Application Default Credentials. מידע נוסף זמין במאמר הגדרת אימות לספריות לקוח.

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#

למידע נוסף, קראו את מאמרי העזרה של Cloud Storage C# API.

כדי לבצע אימות ב-Cloud Storage, אתם צריכים להגדיר את Application Default Credentials. מידע נוסף זמין במאמר הגדרת אימות לספריות לקוח.

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

למידע נוסף, קראו את מאמרי העזרה של Cloud Storage Go API.

כדי לבצע אימות ב-Cloud Storage, אתם צריכים להגדיר את Application Default Credentials. מידע נוסף זמין במאמר הגדרת אימות לספריות לקוח.

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

למידע נוסף, קראו את מאמרי העזרה של Cloud Storage Java API.

כדי לבצע אימות ב-Cloud Storage, אתם צריכים להגדיר את Application Default Credentials. מידע נוסף זמין במאמר הגדרת אימות לספריות לקוח.

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

למידע נוסף, קראו את מאמרי העזרה של Cloud Storage Node.js API.

כדי לבצע אימות ב-Cloud Storage, אתם צריכים להגדיר את Application Default Credentials. מידע נוסף זמין במאמר הגדרת אימות לספריות לקוח.

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

למידע נוסף, קראו את מאמרי העזרה של Cloud Storage PHP API.

כדי לבצע אימות ב-Cloud Storage, אתם צריכים להגדיר את Application Default Credentials. מידע נוסף זמין במאמר הגדרת אימות לספריות לקוח.

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

למידע נוסף, קראו את מאמרי העזרה של Cloud Storage Python API.

כדי לבצע אימות ב-Cloud Storage, אתם צריכים להגדיר את Application Default Credentials. מידע נוסף זמין במאמר הגדרת אימות לספריות לקוח.

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

למידע נוסף, קראו את מאמרי העזרה של Cloud Storage Ruby API.

כדי לבצע אימות ב-Cloud Storage, אתם צריכים להגדיר את Application Default Credentials. מידע נוסף זמין במאמר הגדרת אימות לספריות לקוח.

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

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

  require "google/cloud/storage/control"

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

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

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

  response = storage_control.get_managed_folder request

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

Rust

use google_cloud_storage::client::StorageControl;

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

ממשקי API בארכיטקטורת REST

‫API בפורמט JSON

1. להתקין ולהפעיל את ה-CLI של gcloud, כדי שתוכלו ליצור אסימון גישה לכותרת Authorization.

2. משתמשים בפקודה cURL כדי להעביר ל-API בפורמט JSON בקשה לקבלת תיקיות מנוהלות:

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

   כאשר:

   • ‫BUCKET_NAME הוא שם הקטגוריה שמכילה את התיקיות המנוהלות שרוצים לקבל. לדוגמה, my-bucket.

   • ‫MANAGED_FOLDER_NAME הוא השם של התיקייה המנוהלת, שמוצג כנתיב. לדוגמה, example-dir/. אם התיקייה המנוהלת היא תיקייה בת, צריך להוסיף תו בריחה (escape) לתו הלוכסן (/) בנתיב של התיקייה המנוהלת. לדוגמה, example-dir1%2Fexample-dir2.

העברת תיקייה מנוהלת

המסוף

1. יוצרים תיקייה מנוהלת חדשה בקטגוריית היעד.

2. מעתיקים את כללי מדיניות ה-IAM מהתיקייה המנוהלת המקורית בקטגוריית המקור לתיקייה המנוהלת החדשה בקטגוריית היעד.

3. מעתיקים את האובייקטים מהתיקייה המנוהלת המקורית בקטגוריית המקור לתיקייה המנוהלת החדשה בקטגוריית היעד.

4. מוחקים את התיקייה המנוהלת המקורית מקטגוריית המקור.

שורת הפקודה

כדי להעביר תיקיות מנוהלות ואת האובייקטים שהן מכילות, מריצים את הפקודה gcloud storage mv עם האפשרות --include-managed-folders:

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

כאשר:

• SOURCE_BUCKET הוא השם של הקטגוריה המקורית. לדוגמה, my-source-bucket`.

• ‫DESTINATION_BUCKET הוא השם של הקטגוריה שאליה רוצים להעביר את התיקייה המנוהלת. לדוגמה, my-destination-bucket.

• ‫MANAGED_FOLDER_NAME הוא השם של התיקייה המנוהלת שמעבירים. לדוגמה, my-managed-folder/.

ממשקי API בארכיטקטורת REST

‫API בפורמט JSON

כדי להעביר תיקיות מנוהלות מקטגוריה אחת לאחרת:

1. יוצרים תיקייה מנוהלת חדשה בקטגוריית היעד.

2. מעתיקים את כללי מדיניות ה-IAM מהתיקייה המנוהלת המקורית בקטגוריית המקור לתיקייה המנוהלת החדשה בקטגוריית היעד.

3. מעתיקים את האובייקטים מהתיקייה המנוהלת המקורית בקטגוריית המקור לתיקייה המנוהלת החדשה בקטגוריית היעד.

4. מוחקים את התיקייה המנוהלת המקורית מקטגוריית המקור.

עדכון מדיניות ההטמעה בזמן הכתיבה של Rapid Cache בתיקייה מנוהלת

בקטע הזה מוסבר איך להפעיל או להשבית את ההגדרה "הטמעה בזמן כתיבה" של Rapid Cache ברמת הקידומת, שמשתמשת בתיקיות מנוהלות כמנגנון בסיסי. אם אתם לא משתמשים ב-Rapid Cache או בתכונה ingest-on-write, אתם יכולים לדלג על החלק הזה.

כדי להפעיל או להשבית את מדיניות ההטמעה בזמן הכתיבה של Rapid Cache לאובייקטים שמשתמשים באותה תחילית של תיקייה מנוהלת, צריך לעדכן את ההגדרות של rapidCacheConfig בתיקייה המנוהלת. ההוראות האלה נדרשות רק כשמשתמשים ב-API בפורמט JSON כדי לעדכן את מדיניות ההטמעה בזמן הכתיבה של המטמון.

למידע נוסף על הפעלה או השבתה של הטמעה בזמן כתיבה ברמת הקידומת, קראו את המאמר הסבר על הטמעה בזמן כתיבה.

ממשקי API בארכיטקטורת REST

‫API בפורמט JSON

כדי להוסיף, לשנות או למחוק את מדיניות ה-ingest-on-write של Rapid Cache בתיקייה מנוהלת:

1. מוודאים שהגדרתם את המאפיין ingestOnWrite בהגדרות של המטמון. כדי לדעת איזה ערך להגדיר למאפיין, קראו את המאמר הסבר על הטמעה בזמן כתיבה.

2. משתמשים ב-cURL כדי לשלוח קריאה ל-API בפורמט JSON באמצעות בקשת PATCH ManagedFolder. גוף הבקשה משתנה בהתאם לתרחיש לדוגמה:

   הפעלה או השבתה של מדיניות ההטמעה בזמן הכתיבה בתיקייה מנוהלת

   כדי לעדכן את הגדרת ההטמעה בזמן הכתיבה למטמון אחד או יותר, משתמשים בפקודה הבאה:

   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.googleapis.com/storage/v1/b/BUCKET_NAME/managedFolders/MANAGED_FOLDER_NAME"

   מחליפים את:

   • ‫BUCKET_NAME: שם הקטגוריה שמכילה את התיקייה המנוהלת.

   • ‫MANAGED_FOLDER_NAME: עם השם של התיקייה המנוהלת.

   • ‫RAPID_CACHE_ID: עם המזהה של המטמון, שהוא האזור של המטמון. לדוגמה, us-east1-b.

   • ‫INGEST_VALUE: עם התנהגות ההטמעה של המטמון. כשהערך הוא enabled, מופעלת הטמעה בזמן הכתיבה של תחיליות של תיקיות מנוהלות. כשהערך הוא unspecified, ההתנהגות של הטמעת המטמון בזמן הכתיבה עוברת בירושה מתיקייה מנוהלת ברמת ההורה, אם היא קיימת, או מהגדרת המטמון בקטגוריה. מידע נוסף על ההתנהגויות שנקבעות על ידי הערכים האלה זמין במאמר דרישות להטמעה בזמן כתיבה. חשוב לקרוא בעיון את המידע על העברת הרשאות בירושה בהטמעה בזמן כתיבה כדי להבין איך מדיניות ההטמעה בזמן כתיבה של המטמון יכולה להיות מושפעת כשההגדרה ingestOnWrite של המטמון מוגדרת ל-unspecified.

   כדי להגדיר הטמעה בזמן כתיבה לכמה מטמונים בו-זמנית, צריך לכלול כמה מפות policies בבקשה. לדוגמה:

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

   כדי להשבית את ההטמעה ברמת הקידומת בזמן הכתיבה למטמונים ספציפיים, מסירים את המפה policies של המטמון מההגדרה rapidCacheConfig.

   מחיקת מדיניות הטמעה בזמן כתיבה בתיקייה מנוהלת

   כדי למחוק את מדיניות ההטמעה בזמן הכתיבה בתיקייה מנוהלת, פועלים לפי ההוראות בקטע הזה. כשמוחקים את מדיניות ההטמעה בזמן הכתיבה בתיקייה מנוהלת, המטמונים שציינתם בבקשה לא יטמיעו אובייקטים בזמן הכתיבה לפי הקידומת של התיקייה המנוהלת שלהם, וההתנהגות של הטמעת האובייקטים בקטגוריה תיקבע לפי השדה ingestOnWrite של הגדרת המטמון. כדי להבין איך השדה ingestOnWrite של תיקייה מנוהלת קובע את ההתנהגות של ingest-on-write בהשוואה להגדרת מטמון, קראו את המאמרים הסבר על הפעלת ingest-on-write וירושה של ingest-on-write.

   כדי למחוק את מדיניות ההטמעה בזמן הכתיבה של תיקייה מנוהלת, משתמשים בפקודה הבאה: הפקודה הבאה משביתה את ההטמעה בזמן הכתיבה ברמת הקידומת במטמונים נפרדים של משאב התיקייה המנוהלת שמכיל את ההגדרה הזו:

   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.googleapis.com/storage/v1/b/BUCKET_NAME/managedFolders/MANAGED_FOLDER_NAME"

   מחליפים את:

   • ‫BUCKET_NAME: שם הקטגוריה שמכילה את התיקייה המנוהלת.

   • ‫MANAGED_FOLDER_NAME: עם השם של התיקייה המנוהלת.

   • ‫RAPID_CACHE_ID: עם המזהה של המטמון, שהוא האזור של המטמון. לדוגמה, us-east1-b. הערך בשדה הזה חייב להיות null.

   לחלופין, כדי למחוק את המדיניות ברמת הקידומת של הטמעה בזמן הכתיבה בתיקייה מנוהלת, מגדירים את המפה policies לערך null בבקשה:

   "rapidCacheConfig": {
   "policies": null
   }

מחיקת תיקייה מנוהלת

המסוף

1. במסוף Google Cloud , נכנסים לדף Buckets של Cloud Storage.
   

   כניסה לדף Buckets

2. ברשימת הקטגוריות, לוחצים על השם של הקטגוריה שמכילה את התיקייה המנוהלת שרוצים למחוק.

3. בדף Bucket details, לוחצים על הסמל More options ליד התיקייה המנוהלת שרוצים למחוק.

4. לוחצים על מחיקת התיקייה.

5. כדי לאשר שרוצים למחוק את התיקייה המנוהלת, מקלידים DELETE בשדה Delete.

6. לוחצים על Delete.

   התיקייה המנוהלת והתוכן שלה, כולל אובייקטים מאוחסנים ותיקיות מנוהלות אחרות, נמחקים מהקטגוריה של Cloud Storage.

שורת הפקודה

כדי למחוק תיקייה מנוהלת ואת האובייקטים שהיא מכילה, מריצים את הפקודה gcloud storage rm:

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

כאשר:

• ‫BUCKET_NAME הוא שם הקטגוריה שמכילה את התיקייה המנוהלת שרוצים למחוק. לדוגמה, my-bucket.

• ‫MANAGED_FOLDER_NAME הוא השם של התיקייה המנוהלת שרוצים למחוק. לדוגמה, my-managed-folder/.

ספריות לקוח

C++

למידע נוסף, קראו את מאמרי העזרה של Cloud Storage C++ API.

כדי לבצע אימות ב-Cloud Storage, אתם צריכים להגדיר את Application Default Credentials. מידע נוסף זמין במאמר הגדרת אימות לספריות לקוח.

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#

למידע נוסף, קראו את מאמרי העזרה של Cloud Storage C# API.

כדי לבצע אימות ב-Cloud Storage, אתם צריכים להגדיר את Application Default Credentials. מידע נוסף זמין במאמר הגדרת אימות לספריות לקוח.

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

למידע נוסף, קראו את מאמרי העזרה של Cloud Storage Go API.

כדי לבצע אימות ב-Cloud Storage, אתם צריכים להגדיר את Application Default Credentials. מידע נוסף זמין במאמר הגדרת אימות לספריות לקוח.

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

למידע נוסף, קראו את מאמרי העזרה של Cloud Storage Java API.

כדי לבצע אימות ב-Cloud Storage, אתם צריכים להגדיר את Application Default Credentials. מידע נוסף זמין במאמר הגדרת אימות לספריות לקוח.

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

למידע נוסף, קראו את מאמרי העזרה של Cloud Storage Node.js API.

כדי לבצע אימות ב-Cloud Storage, אתם צריכים להגדיר את Application Default Credentials. מידע נוסף זמין במאמר הגדרת אימות לספריות לקוח.

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

למידע נוסף, קראו את מאמרי העזרה של Cloud Storage PHP API.

כדי לבצע אימות ב-Cloud Storage, אתם צריכים להגדיר את Application Default Credentials. מידע נוסף זמין במאמר הגדרת אימות לספריות לקוח.

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

למידע נוסף, קראו את מאמרי העזרה של Cloud Storage Python API.

כדי לבצע אימות ב-Cloud Storage, אתם צריכים להגדיר את Application Default Credentials. מידע נוסף זמין במאמר הגדרת אימות לספריות לקוח.

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

למידע נוסף, קראו את מאמרי העזרה של Cloud Storage Ruby API.

כדי לבצע אימות ב-Cloud Storage, אתם צריכים להגדיר את Application Default Credentials. מידע נוסף זמין במאמר הגדרת אימות לספריות לקוח.

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

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

  require "google/cloud/storage/control"

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

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

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

  storage_control.delete_managed_folder request

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

Rust

use google_cloud_storage::client::StorageControl;

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

ממשקי API בארכיטקטורת REST

‫API בפורמט JSON

כדי למחוק תיקייה מנוהלת, קודם צריך למחוק את האובייקטים שבתוך התיקייה המנוהלת.

1. להתקין ולהפעיל את ה-CLI של gcloud, כדי שתוכלו ליצור אסימון גישה לכותרת Authorization.

2. משתמשים ב-cURL כדי לשלוח קריאה ל-API בפורמט JSON באמצעות בקשת תיקייה מנוהלת של DELETE:

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

   כאשר:

   • ‫BUCKET_NAME הוא שם הקטגוריה שמכילה את התיקייה המנוהלת שרוצים למחוק. לדוגמה, my-bucket.

   • ‫MANAGED_FOLDER_NAME הוא השם של התיקייה המנוהלת שרוצים למחוק. לדוגמה, my-managed-folder/.

   כברירת מחדל, תיקיות מנוהלות חייבות להיות ריקות כדי שיהיה אפשר למחוק אותן. כדי למחוק תיקייה מנוהלת שלא ריקה, צריך לכלול את allowNonEmpty=true כפרמטר של שאילתה בבקשה.

פתרון בעיות

לקבלת עזרה ביצירה ובניהול של תיקיות מנוהלות, אפשר לעיין בדף פתרון הבעיות.

המאמרים הבאים

• הגדרת מדיניות IAM בתיקייה מנוהלת.

• הצגת רשימה של אובייקטים בתיקיות מנוהלות.

• מידע ולמידה על שיטות מומלצות לשימוש בתיקיות מנוהלות