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

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

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

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

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

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

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

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

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

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

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

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

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

  • כדי ליצור תיקיות מנוהלות: 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 כדי ליצור תיקייה חדשה. אם התיקייה שרוצים להמיר לתיקייה מנוהלת כבר קיימת, אפשר לדלג לשלב שבו מתואר איך לגשת לתפריט אפשרויות נוספות .

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

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

    התיקייה החדשה שנוצרה מופיעה בחלונית Folder browser (דפדפן התיקיות).

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

    מופיעה תיבת הדו-שיח Enable folder management?‎ (הפעלת ניהול תיקיות).

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

    התיקייה תומר לתיקייה מנוהלת. מוצג החלונית Permissions for MANAGED_FOLDER_NAME (הרשאות ל-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 ManagedFolder:

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

    כאשר:

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

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

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

    בקטע הזה מוסבר איך ליצור תיקייה מנוהלת עם הגדרות שמפעילות את התכונה 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./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, משתמשים בtoggle node כדי להרחיב את רשימת התיקיות בקטגוריה.

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

שורת הפקודה

כדי להציג רשימה של תיקיות מנוהלות, מריצים את הפקודה 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./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./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 שלו, אתם יכולים לדלג על הקטע הזה.

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

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

ממשקי API ל-REST

‫API בפורמט JSON

כדי להוסיף, לשנות או למחוק את מדיניות ההטמעה של 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./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 של תיקייה מנוהלת לעומת הגדרת מטמון, אפשר לעיין במאמרים הסבר על הפעלת הטמעה בכתיבה והורשה של הטמעה בכתיבה.

    כדי למחוק את מדיניות ההעברה בכתיבה של תיקייה מנוהלת, משתמשים בפקודה הבאה. הפקודה הבאה משביתה את ההטמעה של prefix-level 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./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 (פרטי מאגר), לוחצים על סמל האפשרויות הנוספות לצד התיקייה המנוהלת שרוצים למחוק.

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

  5. כדי לאשר שרוצים למחוק את התיקייה המנוהלת, מקלידים 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 ManagedFolder:

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

    כאשר:

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

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

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

פתרון בעיות

בדף פתרון הבעיות מוסבר איך ליצור ולנהל תיקיות מנוהלות.

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