יצירת קטגוריה

המסוף

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

   כניסה לדף Buckets

2. לוחצים על add_box Create.

3. ממלאים את פרטי הקטגוריה בדף Create a bucket. אחרי כל אחד מהשלבים הבאים, לוחצים על Continue כדי להמשיך לשלב הבא:

   1. בקטע Get started:

      • מזינים שם ייחודי גלובלי שעומד בדרישות לשמות של קטגוריות.

      • כדי להוסיף תווית לקטגוריה, לוחצים על החץ להרחבה expand_more כדי להרחיב את הקטע Labels, לוחצים על add_box Add label ומציינים key ו-value בשביל התווית.

   2. בקטע Choose where to store your data מבצעים את הפעולות הבאות:

      1. בוחרים Location type.

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

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

      3. כדי להגדיר רפליקציה בין קטגוריות, בוחרים באפשרות Add cross-bucket replication via Storage Transfer Service ופועלים לפי השלבים הבאים:

         הגדרת רפליקציה בין קטגוריות

         1. בתפריט Bucket בוחרים קטגוריה.

         2. בקטע Replication settings, לוחצים על Configure כדי לקבוע את ההגדרות של משימת הרפליקציה.

            מופיעה החלונית Configure cross-bucket replication.

            • כדי לסנן אובייקטים לשכפול לפי קידומת של שם האובייקט, מזינים קידומת שרוצים לכלול או להחריג אובייקטים, ואז לוחצים על add Add a prefix.
            • כדי להגדיר סוג אחסון לאובייקטים המשוכפלים, בוחרים סוג אחסון מהתפריט Storage class. אם מדלגים על השלב הזה, האובייקטים המשוכפלים ישתמשו כברירת מחדל בסוג האחסון של קטגוריית היעד.
            • לוחצים על סיום.

   3. בקטע Choose how to store your data:

      1. בוחרים סוג אחסון (storage class) שמוגדר כברירת מחדל לקטגוריה, או בוחרים ב-Autoclass לניהול אוטומטי של סוג האחסון של נתוני הקטגוריה.

      2. בקטע Optimize storage for data-intensive workloads:

         • כדי להפעיל מרחב שמות היררכי, בוחרים באפשרות Enable Hierarchical namespace on this bucket.

         • כדי להפעיל את Rapid Cache, בוחרים באפשרות Enable Rapid Cache ופועלים לפי השלבים הבאים:

           1. כדי ליצור מטמונים, לוחצים על הגדרה.

           2. בתיבת הדו-שיח Configure cache settings שמופיעה, לוחצים על החץ לתפריט הנפתח לצד האזורים שברשימה ובוחרים את האזורים שבהם רוצים ליצור מטמונים.

           3. לוחצים על סיום.

   4. בקטע Choose how to control access to objects:

      1. בוחרים אם הקטגוריה אוכפת מניעת גישה ציבורית.

      2. בוחרים מודל בקרת גישה לאובייקטים של הקטגוריה. מומלץ לבחור באפשרות Uniform כדי להפעיל גישה אחידה ברמת הקטגוריה.

      3. כדי להגדיר סינון IP לקטגוריה:

         1. בקטע IP filtering, לוחצים על add_box Configure.

         2. כדי לאפשר גישה מכתובות IP ציבוריות:

            1. לוחצים על אינטרנט ציבורי.

            2. בשדה Allowed IP range(s), מציינים טווח אחד או יותר של כתובות IPv4 או טווחי CIDR של IPv6 שרוצים לאפשר. לדוגמה, 192.0.2.0/24 או 2001:db8::/32.

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

         3. כדי לאפשר גישה מרשתות VPC:

            1. לוחצים על רשתות VPC.

            2. מבצעים את הפעולות הבאות בכל רשת:

               1. לוחצים על Add VPC network.

               2. בקטע New VPC network, מציינים את הפרטים הבאים:

                  • בשדה Project ID, מזינים את מזהה הפרויקט.
                  • בשדה שם הרשת, מזינים את שם הרשת.

                  • בשדה Allowed IP range(s), מזינים טווח CIDR אחד או יותר של IPv4 או IPv6, כמו 192.0.2.0/24 או 2001:db8::/32.

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

               3. לוחצים על סיום.

         4. כדי לאפשר לסוכני שירות ורשתות VPC מהימנים מארגונים אחרים לעקוף את הגדרת סינון ה-IP, צריך לבצע את הפעולות הבאות: Google Cloud

            1. לוחצים על הגדרות נוספות.

            2. בקטע Google Cloud service agent access, בוחרים אחת מהאפשרויות הבאות:

               • ‫Allow service agent access: מאפשר לשירותים של Google Cloud כמו BigLake,‏ Storage Insights,‏ Vertex AI ו-BigQuery לעקוף את אימות סינון ה-IP כשהם צריכים לגשת לקטגוריה הזו.
               • דחיית הגישה של סוכן השירות: אכיפה של כללי סינון ה-IP על סוכני השירות של Google Cloud .
            3. בקטע Cross-organization VPC access, מבצעים אחת מהפעולות הבאות:
               • כדי לאפשר גישה מרשתות VPC ספציפיות שנמצאות בארגונים שונים ב- Google Cloud , לוחצים על המתג כדי להעביר אותו למצב Allow.
               • כדי לחסום את הגישה מרשתות VPC מחוץ לארגון ב- Google Cloud , לוחצים על המתג כדי להעביר אותו למצב דחייה (מצב ברירת המחדל).
         5. לוחצים על בדיקה ואז על שמירה.

   5. בקטע Choose how to protect object data:

      • בוחרים את האפשרויות שרוצים להגדיר לקטגוריה בקטע הגנה על נתונים.

      • כדי לשנות את משך הזמן שבו האובייקטים נשמרים אחרי המחיקה באמצעות מחיקה רכה, מסמנים את התיבה Soft delete policy ובוחרים באפשרות Set custom retention duration. לאחר מכן, מציינים את משך הזמן שרוצים לשמור אובייקטים שנמחקו.

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

      • כדי לבחור איך להצפין את נתוני האובייקט, לוחצים על החץ להרחבה expand_more שנקרא Data encryption ומבצעים את הפעולות הבאות:

        • בקטע Default encryption key type, בוחרים את מפתח ההצפנה שמוגדר כברירת מחדל לקטגוריה. אם בוחרים באפשרות Cloud KMS key, צריך לספק מפתח של Cloud Key Management Service.
        • בקטע Encryption enforcement rules, בשדה Key types בוחרים אילו סוגי הצפנה לאפשר או להגביל לאובייקטים חדשים בקטגוריה.

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

במאמר פתרון בעיות מוסבר איך מקבלים מידע מפורט על שגיאות בנושא פעולות ב-Cloud Storage שנכשלו במסוף Google Cloud .

שורת הפקודה

1. מפעילים את Cloud Shell במסוף Google Cloud .

   הפעלת Cloud Shell

   בחלק התחתון של מסוף Google Cloud יתחיל סשן של Cloud Shell ותופיע הודעה של שורת הפקודה. Cloud Shell היא סביבת מעטפת שבה ה-CLI של Google Cloud מותקן ומוגדרים ערכים לפרויקט הקיים. הסשן יופעל תוך כמה שניות.

2. בסביבת הפיתוח, מריצים את הפקודה gcloud storage buckets create:

   gcloud storage buckets create gs://BUCKET_NAME --location=BUCKET_LOCATION

   כאשר:

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

   • ‫BUCKET_LOCATION הוא המיקום של הקטגוריה. לדוגמה, US.

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

   Creating gs://BUCKET_NAME/...

   מגדירים את הדגלים הבאים כדי לקבל שליטה טובה יותר ביצירת הקטגוריה:

   • ‫--project: ציון מזהה הפרויקט או מספר הפרויקט שאליהם הקטגוריה תשויך. לדוגמה, my-project.
   • ‫--default-storage-class: ציון סוג האחסון של הקטגוריה שמוגדר כברירת מחדל. לדוגמה, STANDARD.
   • ‫--uniform-bucket-level-access: הפעלת גישה אחידה ברמת הקטגוריה בשביל הקטגוריה.
   • ‫--soft-delete-duration: מציינים את משך הזמן של המחיקה הרכה, כלומר מספר הימים שבהם רוצים לשמור את האובייקטים אחרי שהם נמחקים. לדוגמה, 10d.
   • ‫--encryption-enforcement-file: מספקים קובץ שמגדיר אילו שיטות הצפנה מוגבלות או מותרות לאובייקטים חדשים בקטגוריה.

   לדוגמה:

   gcloud storage buckets create gs://BUCKET_NAME --project=PROJECT_ID --default-storage-class=STORAGE_CLASS --location=BUCKET_LOCATION --uniform-bucket-level-access
   --soft-delete-duration=RETENTION_DURATION --encryption-enforcement-file=ENCRYPTION_ENFORCEMENT_FILE
   

   רשימת האפשרויות המלאה ליצירת קטגוריות באמצעות ה-CLI של gcloud מופיעה במאמר אפשרויות של buckets create.

ספריות לקוח

namespace gcs = ::google::cloud::storage;
using ::google::cloud::StatusOr;
[](gcs::Client client, std::string const& bucket_name,
   std::string const& storage_class, std::string const& location) {
  StatusOr<gcs::BucketMetadata> bucket_metadata =
      client.CreateBucket(bucket_name, gcs::BucketMetadata()
                                           .set_storage_class(storage_class)
                                           .set_location(location));
  if (!bucket_metadata) throw std::move(bucket_metadata).status();

  std::cout << "Bucket " << bucket_metadata->name() << " created."
            << "\nFull Metadata: " << *bucket_metadata << "\n";
}

using Google.Apis.Storage.v1.Data;
using Google.Cloud.Storage.V1;
using System;

public class CreateRegionalBucketSample
{
    /// <summary>
    /// Creates a storage bucket with region.
    /// </summary>
    /// <param name="projectId">The ID of the project to create the buckets in.</param>
    /// <param name="location">The location of the bucket. Object data for objects in the bucket resides in 
    /// physical storage within this region. Defaults to US.</param>
    /// <param name="bucketName">The name of the bucket to create.</param>
    /// <param name="storageClass">The bucket's default storage class, used whenever no storageClass is specified
    /// for a newly-created object. This defines how objects in the bucket are stored
    /// and determines the SLA and the cost of storage. Values include MULTI_REGIONAL,
    /// REGIONAL, STANDARD, NEARLINE, COLDLINE, ARCHIVE, and DURABLE_REDUCED_AVAILABILITY.
    /// If this value is not specified when the bucket is created, it will default to
    /// STANDARD.</param>
    public Bucket CreateRegionalBucket(
        string projectId = "your-project-id",
        string bucketName = "your-unique-bucket-name",
        string location = "us-west1",
        string storageClass = "REGIONAL")
    {
        var storage = StorageClient.Create();
        Bucket bucket = new Bucket
        {
            Location = location,
            Name = bucketName,
            StorageClass = storageClass
        };
        var newlyCreatedBucket = storage.CreateBucket(projectId, bucket);
        Console.WriteLine($"Created {bucketName}.");
        return newlyCreatedBucket;
    }
}

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

	"cloud.google.com/go/storage"
)

// createBucketClassLocation creates a new bucket in the project with Storage class and
// location.
func createBucketClassLocation(w io.Writer, projectID, bucketName string) error {
	// projectID := "my-project-id"
	// bucketName := "bucket-name"
	ctx := context.Background()
	client, err := storage.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("storage.NewClient: %w", err)
	}
	defer client.Close()

	ctx, cancel := context.WithTimeout(ctx, time.Second*30)
	defer cancel()

	storageClassAndLocation := &storage.BucketAttrs{
		StorageClass: "COLDLINE",
		Location:     "asia",
	}
	bucket := client.Bucket(bucketName)
	if err := bucket.Create(ctx, projectID, storageClassAndLocation); err != nil {
		return fmt.Errorf("Bucket(%q).Create: %w", bucketName, err)
	}
	fmt.Fprintf(w, "Created bucket %v in %v with storage class %v\n", bucketName, storageClassAndLocation.Location, storageClassAndLocation.StorageClass)
	return nil
}

import com.google.cloud.storage.Bucket;
import com.google.cloud.storage.BucketInfo;
import com.google.cloud.storage.Storage;
import com.google.cloud.storage.StorageClass;
import com.google.cloud.storage.StorageOptions;

public class CreateBucketWithStorageClassAndLocation {
  public static void createBucketWithStorageClassAndLocation(String projectId, String bucketName) {
    // The ID of your GCP project
    // String projectId = "your-project-id";

    // The ID to give your GCS bucket
    // String bucketName = "your-unique-bucket-name";

    Storage storage = StorageOptions.newBuilder().setProjectId(projectId).build().getService();

    // See the StorageClass documentation for other valid storage classes:
    // https://googleapis.dev/java/google-cloud-clients/latest/com/google/cloud/storage/StorageClass.html
    StorageClass storageClass = StorageClass.COLDLINE;

    // See this documentation for other valid locations:
    // http://g.co/cloud/storage/docs/bucket-locations#location-mr
    String location = "ASIA";

    Bucket bucket =
        storage.create(
            BucketInfo.newBuilder(bucketName)
                .setStorageClass(storageClass)
                .setLocation(location)
                .build());

    System.out.println(
        "Created bucket "
            + bucket.getName()
            + " in "
            + bucket.getLocation()
            + " with storage class "
            + bucket.getStorageClass());
  }
}

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// The ID of your GCS bucket
// const bucketName = 'your-unique-bucket-name';

// The name of a storage class
// See the StorageClass documentation for other valid storage classes:
// https://googleapis.dev/java/google-cloud-clients/latest/com/google/cloud/storage/StorageClass.html
// const storageClass = 'coldline';

// The name of a location
// See this documentation for other valid locations:
// http://g.co/cloud/storage/docs/locations#location-mr
// const location = 'ASIA';

// Imports the Google Cloud client library
const {Storage} = require('@google-cloud/storage');

// Creates a client
// The bucket in the sample below will be created in the project associated with this client.
// For more information, please see https://cloud.google.com/docs/authentication/production or https://googleapis.dev/nodejs/storage/latest/Storage.html
const storage = new Storage();

async function createBucketWithStorageClassAndLocation() {
  // For default values see: https://cloud.google.com/storage/docs/locations and
  // https://cloud.google.com/storage/docs/storage-classes
  const [bucket] = await storage.createBucket(bucketName, {
    location,
    [storageClass]: true,
  });

  console.log(
    `${bucket.name} created with ${storageClass} class in ${location}`
  );
}

createBucketWithStorageClassAndLocation().catch(console.error);

use Google\Cloud\Storage\StorageClient;

/**
 * Create a new bucket with a custom default storage class and location.
 *
 * @param string $bucketName The name of your Cloud Storage bucket.
 *        (e.g. 'my-bucket')
 */
function create_bucket_class_location(string $bucketName): void
{
    $storage = new StorageClient();
    $storageClass = 'COLDLINE';
    $location = 'ASIA';
    $bucket = $storage->createBucket($bucketName, [
        'storageClass' => $storageClass,
        'location' => $location,
    ]);

    $objects = $bucket->objects([
        'encryption' => [
            'defaultKmsKeyName' => null,
        ]
    ]);

    printf('Created bucket %s in %s with storage class %s', $bucketName, $storageClass, $location);
}

from google.cloud import storage


def create_bucket_class_location(bucket_name):
    """
    Create a new bucket in the US region with the coldline storage
    class
    """
    # bucket_name = "your-new-bucket-name"

    storage_client = storage.Client()

    bucket = storage_client.bucket(bucket_name)
    bucket.storage_class = "COLDLINE"
    new_bucket = storage_client.create_bucket(bucket, location="us")

    print(
        "Created bucket {} in {} with storage class {}".format(
            new_bucket.name, new_bucket.location, new_bucket.storage_class
        )
    )
    return new_bucket

def create_bucket_class_location bucket_name:
  # The ID to give your GCS bucket
  # bucket_name = "your-unique-bucket-name"

  require "google/cloud/storage"

  storage = Google::Cloud::Storage.new
  bucket  = storage.create_bucket bucket_name,
                                  location:      "ASIA",
                                  storage_class: "COLDLINE"

  puts "Created bucket #{bucket.name} in #{bucket.location} with #{bucket.storage_class} class"
end

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

pub async fn sample(
    client: &StorageControl,
    project_id: &str,
    bucket_id: &str,
) -> anyhow::Result<()> {
    let bucket = client
        .create_bucket()
        .set_parent("projects/_")
        .set_bucket_id(bucket_id)
        .set_bucket(
            Bucket::new()
                .set_project(format!("projects/{project_id}"))
                .set_storage_class("NEARLINE")
                .set_location("US-CENTRAL1"),
        )
        .send()
        .await?;
    println!("successfully created bucket {bucket:?}");
    Ok(())
}

Terraform

אפשר להשתמש במשאב של Terraform כדי ליצור קטגוריית אחסון.

# Create new storage bucket in the US multi-region
# with coldline storage
resource "random_id" "bucket_prefix" {
  byte_length = 8
}

resource "google_storage_bucket" "static" {
  name          = "${random_id.bucket_prefix.hex}-new-bucket"
  location      = "US"
  storage_class = "COLDLINE"

  uniform_bucket_level_access = true
}

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