יצירה וניהול של מטמונים באמצעות Rapid Cache

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

בדף הזה מוסבר איך ליצור ולנהל מופעי מטמון באמצעות Rapid Cache. מידע על שימוש בפעולות ממושכות וניהול שלהן שמופעלות מ-Rapid Cache כפעולות אסינכרוניות של מטמון זמין במאמר שימוש בפעולות ממושכות.

לפני שמשתמשים ב-Rapid Cache, כדאי לעיין במגבלות והגבלות.

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

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

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

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

כדי ליצור ולנהל מטמון של Rapid Cache, נדרשות ההרשאות הבאות:

  • ‫storage.anywhereCaches.create (נדרש ליצירת מטמונים)
  • ‫storage.anywhereCaches.disable (נדרש להשבתת מטמונים)
  • storage.anywhereCaches.get (נדרש כדי לקבל מטמון)
  • ‫storage.anywhereCaches.list (חובה כשמציגים רשימת מטמונים)
  • ‫storage.anywhereCaches.resume (נדרש להפעלת מטמון מחדש)
  • storage.anywhereCaches.update (נדרש לעדכון מטמונים)

אפשר לקבל את ההרשאות האלה גם באמצעות תפקידים בהתאמה אישית.

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

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

יצירת מטמון

המסוף

כדי ליצור מטמון בקטגוריה קיימת:

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

    כניסה לדף Buckets

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

  3. בדף Bucket details, לוחצים על הכרטיסייה Configuration.

  4. בקטע Anywhere Cache, לוחצים על Configure cache.

    יופיע הדף Configure cache של הקטגוריה.

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

  6. בקטע Cache zones (אזורי מטמון), בוחרים את האזורים שבהם רוצים ליצור מטמון. לכל אזור שבוחרים, מגדירים זמן חיים (TTL) וקריטריונים להעברת נתונים.

    • כדי להגדיר TTL: בעמודה Time to live (אורך חיים), מזינים משך זמן בשדה Duration* (משך)* ובוחרים יחידת זמן.

    • כדי להגדיר את הקריטריונים להעברת נתונים: בעמודה קריטריונים להעברת נתונים, לוחצים על עריכה. בחלונית Set ingestion criteria (הגדרת קריטריונים להעברה) שמופיעה, בוחרים אפשרות להעברת נתונים ולוחצים על Done (סיום).

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

  8. בתיבת הדו-שיח שמופיעה, לוחצים על Confirm.

    הכרטיסייה Operations בדף Bucket details נפתחת ומוצג בה סטטוס העבודה של פעולת יצירת המטמון.

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

כדי לראות את סטטוס המטמון של קטגוריה בדף רשימת הקטגוריות:

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

    כניסה לדף Buckets

  2. לוחצים על סמל הצגת עמודה (), בוחרים באפשרות מטמון ולוחצים על אישור.

שורת הפקודה

משתמשים בפקודה gcloud storage buckets anywhere-caches create:

gcloud storage buckets anywhere-caches create gs://BUCKET_NAME CACHE_ZONE \
[--ttl=TTL] [--enable-ingest-on-write]

מחליפים את:

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

  • ‫CACHE_ZONE עם האזור שבו המטמון יפעל. לדוגמה, us-east1-b.

    כדי ליצור כמה מטמונים בבת אחת, אפשר לציין כמה אזורים. לדוגמה, us-east1-b us-east1-c us-east1-d.

  • ‫TTL (אופציונלי) עם אורך החיים (TTL) של הנתונים במטמון. הערך יכול להיות בין יום אחד ל-7 ימים, כולל. הערך יכול להיות בשניות, דקות, שעות וימים. לדוגמה:

    • ‫86400s למשך 86,400 שניות
    • ‫1440m למשך 1,440 דקות
    • ‫24h למשך 24 שעות
    • ‫1d ליום

    אם לא מציינים ערך, ברירת המחדל היא 86400s (יום אחד).

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

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

ספריות לקוח

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& cache_name,
   std::string const& zone_name) {
  google::storage::control::v2::AnywhereCache cache;
  cache.set_name(cache_name);
  cache.set_zone(zone_name);

  google::storage::control::v2::CreateAnywhereCacheRequest request;
  request.set_parent(std::string{"projects/_/buckets/"} + bucket_name);
  *request.mutable_anywhere_cache() = cache;

  // Start a create operation and block until it completes. Real applications
  // may want to setup a callback, wait on a coroutine, or poll until it
  // completes.
  auto anywhere_cache = client.CreateAnywhereCache(request).get();
  if (!anywhere_cache) throw std::move(anywhere_cache).status();
  std::cout << "Created anywhere cache: " << anywhere_cache->name() << "\n";
}

Java

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

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

import com.google.api.gax.longrunning.OperationFuture;
import com.google.storage.control.v2.AnywhereCache;
import com.google.storage.control.v2.BucketName;
import com.google.storage.control.v2.CreateAnywhereCacheMetadata;
import com.google.storage.control.v2.CreateAnywhereCacheRequest;
import com.google.storage.control.v2.StorageControlClient;
import java.io.IOException;
import java.util.concurrent.ExecutionException;

public final class AnywhereCacheCreate {

  public static void anywhereCacheCreate(String bucketName, String cacheName, String zoneName)
      throws InterruptedException, ExecutionException, IOException {
    try (StorageControlClient storageControl = StorageControlClient.create()) {

      CreateAnywhereCacheRequest request =
          CreateAnywhereCacheRequest.newBuilder()
              // Set project to "_" to signify globally scoped bucket
              .setParent(BucketName.format("_", bucketName))
              .setAnywhereCache(
                  AnywhereCache.newBuilder().setName(cacheName).setZone(zoneName).build())
              .build();

      // Start a long-running operation (LRO).
      OperationFuture<AnywhereCache, CreateAnywhereCacheMetadata> operation =
          storageControl.createAnywhereCacheAsync(request);

      // Await the LROs completion.
      AnywhereCache anywhereCache = operation.get();
      System.out.printf("Created anywhere cache: %s%n", anywhereCache.getName());
    }
  }
}

Rust

use google_cloud_lro::Poller;
use google_cloud_storage::client::StorageControl;
use google_cloud_storage::model::AnywhereCache;

pub async fn sample(client: &StorageControl, bucket_id: &str, zone: &str) -> anyhow::Result<()> {
    let cache = client
        .create_anywhere_cache()
        .set_parent(format!("projects/_/buckets/{bucket_id}"))
        .set_anywhere_cache(AnywhereCache::new().set_zone(zone).set_name(format!(
            "projects/_/buckets/{bucket_id}/anywhereCaches/{zone}"
        )))
        .poller()
        .until_done()
        .await?;
    println!("Created anywhere cache: {cache:?}");
    Ok(())
}

Terraform

פרטים על השימוש ב-Rapid Cache עם Terraform זמינים בgoogle_storage_anywhere_cache מאמרי העזרה של Terraform.

ממשקי API ל-REST

‫API בפורמט JSON

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

  2. יוצרים קובץ JSON שמכיל את הפרטים הבאים:

    {
   "zone": "ZONE",
   "ttl": "TIME_TO_LIVE",
   "ingestOnWrite": INGEST_SETTING
}

    מחליפים את:

    • ‫ZONE עם התחום שבו המטמון יפעל. לדוגמה, us-east1-b.

    • ‫TIME_TO_LIVE עם אורך החיים (TTL) של הנתונים במטמון. הערכים יכולים להיות בשניות, בדקות, בשעות ובימים. לדוגמה:

      • ‫86400s למשך 86,400 שניות
      • ‫1440m למשך 1,440 דקות
      • ‫24h למשך 24 שעות
      • ‫1d ליום

      אם לא מציינים ערך, ברירת המחדל היא 86400s (יום אחד). הערך המקסימלי הוא 7 ימים.

    • ‫INGEST_SETTING עם true או false כדי לציין אם המטמון יקלוט נתונים בזמן כתיבה.

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

    curl -X POST --data-binary @JSON_FILE_NAME \
    -H "Authorization: Bearer $(gcloud auth print-access-token)" \
    -H "Content-Type: application/json" \
    "https://storage.googleapis.com/storage/v1/b/BUCKET_NAME/anywhereCaches"

    מחליפים את:

    • ‫JSON_FILE_NAME בשם של קובץ ה-JSON שיצרתם בשלב 2.

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

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

הצגת מטמון

המסוף

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

    כניסה לדף Buckets

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

  3. בדף Bucket details, לוחצים על הכרטיסייה Configuration.

  4. בקטע Rapid Cache, לוחצים על Edit לצד השדה Cache.

  5. בדף Edit configuration (עריכת ההגדרה) שמופיע, בוחרים אזור כדי לראות את כל מטמוני הנתונים באזורים של האזור.

    בחלונית Cache zones אפשר לראות פרטים על כל מטמון זמין.

שורת הפקודה

משתמשים בפקודה gcloud storage buckets anywhere-caches describe:

gcloud storage buckets anywhere-caches describe CACHE_ID

מחליפים את:

  • ‫CACHE_ID עם המזהה של מופע הזיכרון למטמון, בנוסח הבא: BUCKET_NAME/CACHE_ZONE. לדוגמה, my-bucket/us-east1-b.

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

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

ספריות לקוח

C++

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

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

namespace storagecontrol = google::cloud::storagecontrol_v2;
[](storagecontrol::StorageControlClient client,
   std::string const& cache_name) {
  auto anywhere_cache = client.GetAnywhereCache(cache_name);
  if (!anywhere_cache) throw std::move(anywhere_cache).status();
  std::cout << "Got anywhere cache: " << anywhere_cache->name() << "\n";
}

Java

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

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


import com.google.storage.control.v2.AnywhereCache;
import com.google.storage.control.v2.GetAnywhereCacheRequest;
import com.google.storage.control.v2.StorageControlClient;
import java.io.IOException;

public final class AnywhereCacheGet {

  public static void anywhereCacheGet(String cacheName) throws IOException {
    try (StorageControlClient storageControl = StorageControlClient.create()) {

      GetAnywhereCacheRequest request =
          GetAnywhereCacheRequest.newBuilder().setName(cacheName).build();

      AnywhereCache anywhereCache = storageControl.getAnywhereCache(request);

      System.out.printf("Got anywhere cache: %s%n", anywhereCache.getName());
    }
  }
}

Rust

use google_cloud_storage::client::StorageControl;

pub async fn sample(
    client: &StorageControl,
    bucket_id: &str,
    cache_id: &str,
) -> anyhow::Result<()> {
    let cache = client
        .get_anywhere_cache()
        .set_name(format!(
            "projects/_/buckets/{bucket_id}/anywhereCaches/{cache_id}"
        ))
        .send()
        .await?;
    println!("Got anywhere cache: {:?}", cache);
    Ok(())
}

Terraform

פרטים על השימוש ב-Rapid Cache עם Terraform זמינים בgoogle_storage_anywhere_cache מאמרי העזרה של Terraform.

ממשקי 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/anywhereCaches/RAPID_CACHE_ID"

    מחליפים את:

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

    • ‫RAPID_CACHE_ID עם התחום שבו נמצא המטמון. לדוגמה, us-east1-b.

אם הפעולה בוצעה ללא שגיאות, היא מחזירה משאב AnywhereCache.

הצגת רשימה של מטמונים

המסוף

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

    כניסה לדף Buckets

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

  3. בדף Bucket details, לוחצים על הכרטיסייה Configuration.

  4. בקטע Rapid Cache, לוחצים על Edit לצד השדה Cache.

  5. בדף Edit configuration (עריכת ההגדרה) שמופיע, בוחרים אזור כדי לראות את כל מטמוני הנתונים באזורים האלה.

    כל המטמונים הזמינים לאזורים באזור מופיעים בחלונית Cache zones.

שורת הפקודה

משתמשים בפקודה gcloud storage buckets anywhere-caches list:

gcloud storage buckets anywhere-caches list gs://BUCKET_NAME

מחליפים את:

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

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

אפשר גם להשתמש בדגל --raw כדי להחזיר תגובת API גולמית במקום תגובה סטנדרטית. למידע נוסף על שליטה בהתנהגויות של רשימות, כמו חלוקת תוצאות לדפים, אפשר לעיין במסמכי התיעוד של gcloud storage ls.

ספריות לקוח

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 anywhere_cache : client.ListAnywhereCaches(parent)) {
    if (!anywhere_cache) throw std::move(anywhere_cache).status();
    std::cout << anywhere_cache->name() << "\n";
  }
}

Java

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

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


import com.google.storage.control.v2.AnywhereCache;
import com.google.storage.control.v2.BucketName;
import com.google.storage.control.v2.ListAnywhereCachesRequest;
import com.google.storage.control.v2.StorageControlClient;
import com.google.storage.control.v2.StorageControlClient.ListAnywhereCachesPagedResponse;
import java.io.IOException;

public final class AnywhereCacheList {

  public static void anywhereCacheList(String bucketName) throws IOException {
    try (StorageControlClient storageControl = StorageControlClient.create()) {

      ListAnywhereCachesRequest request =
          ListAnywhereCachesRequest.newBuilder()
              .setParent(BucketName.format("_", bucketName))
              .build();

      ListAnywhereCachesPagedResponse page = storageControl.listAnywhereCaches(request);
      for (AnywhereCache anywhereCache : page.iterateAll()) {
        System.out.println(anywhereCache.getName());
      }
    }
  }
}

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 stream = client
        .list_anywhere_caches()
        .set_parent(format!("projects/_/buckets/{}", bucket_id))
        .by_item();
    while let Some(cache) = stream.next().await {
        println!("Found cache: {:?}", cache?);
    }
    Ok(())
}

Terraform

פרטים על השימוש ב-Rapid Cache עם Terraform זמינים בgoogle_storage_anywhere_cache מאמרי העזרה של Terraform.

ממשקי 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/anywhereCaches"

    מחליפים את:

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

    כשמציגים כמה מטמונים, אפשר לדפדף בתוצאות.

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

עדכון מטמון

המסוף

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

    כניסה לדף Buckets

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

  3. בדף Bucket details, לוחצים על הכרטיסייה Configuration.

  4. בקטע Rapid Cache (מטמון מהיר), לוחצים על Manage caches (ניהול מטמונים).

  5. בחלונית Manage caches, לוחצים על Edit or create caches.

  6. בדף Edit configuration שמופיע, מעדכנים את מאפייני המטמון:

    • כדי לעדכן את ה-TTL של המטמון, מאתרים את העמודה Time to live, מציינים את משך הזמן ובוחרים יחידת זמן (לדוגמה, minutes).

    • כדי להפעיל את ההטמעה בכתיבה:

      1. מאתרים את העמודה קריטריונים להוספה ולוחצים על עריכת קריטריונים להוספת נתונים למטמון.

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

  7. בדף עריכת ההגדרה, לוחצים על שמירה.

  8. בתיבת הדו-שיח שמופיעה, לוחצים על Confirm.

שורת הפקודה

משתמשים בפקודה gcloud storage buckets anywhere-caches update:

gcloud storage buckets anywhere-caches update CACHE_ID \
[--ttl=TTL] [--[no-]enable-ingest-on-write]

מחליפים את:

  • ‫CACHE_ID עם המזהה של מופע הזיכרון למטמון, בנוסח הבא: BUCKET_NAME/CACHE_ZONE. לדוגמה, my-bucket/us-east1-b.

    כדי לעדכן כמה מטמונים בבת אחת, אפשר לציין כמה מזהים. לדוגמה, my-bucket/us-east1-b my-bucket/us-east1-c.

  • ‫TTL (אופציונלי) עם אורך החיים (TTL) של הנתונים במטמון. הערך יכול להיות בין יום אחד ל-7 ימים, כולל. הערך יכול להיות בשניות, דקות, שעות וימים. לדוגמה:

    • ‫86400s למשך 86,400 שניות
    • ‫1440m למשך 1,440 דקות
    • ‫24h למשך 24 שעות
    • ‫1d ליום

כדי להגדיר את המטמון כך שיקלוט נתונים ברגע שהם נכתבים לקטגוריה, מציינים את הדגל --enable-ingest-on-write. כדי להשבית את הטמעת הנתונים בכתיבה, מציינים את הדגל --no-enable-ingest-on-write.

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

ספריות לקוח

C++

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

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

namespace storagecontrol = google::cloud::storagecontrol_v2;
[](storagecontrol::StorageControlClient client,
   std::string const& cache_name) {
  google::storage::control::v2::AnywhereCache cache;
  google::protobuf::FieldMask field_mask;
  field_mask.add_paths("ttl");
  cache.set_name(cache_name);
  cache.mutable_ttl()->set_seconds(86400);
  // Start an update operation and block until it completes. Real applications
  // may want to setup a callback, wait on a coroutine, or poll until it
  // completes.
  auto anywhere_cache = client.UpdateAnywhereCache(cache, field_mask).get();
  if (!anywhere_cache) throw std::move(anywhere_cache).status();
  std::cout << "Updated anywhere cache: " << anywhere_cache->name() << "\n";
}

Java

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

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


import com.google.api.gax.longrunning.OperationFuture;
import com.google.protobuf.FieldMask;
import com.google.storage.control.v2.AnywhereCache;
import com.google.storage.control.v2.StorageControlClient;
import com.google.storage.control.v2.UpdateAnywhereCacheMetadata;
import com.google.storage.control.v2.UpdateAnywhereCacheRequest;
import java.io.IOException;
import java.util.concurrent.ExecutionException;

public final class AnywhereCacheUpdate {

  public static void anywhereCacheUpdate(String cacheName, String admissionPolicy)
      throws InterruptedException, ExecutionException, IOException {
    try (StorageControlClient storageControl = StorageControlClient.create()) {

      AnywhereCache pendingUpdate =
          AnywhereCache.newBuilder().setName(cacheName).setAdmissionPolicy(admissionPolicy).build();

      UpdateAnywhereCacheRequest request =
          UpdateAnywhereCacheRequest.newBuilder()
              .setAnywhereCache(pendingUpdate)
              .setUpdateMask(FieldMask.newBuilder().addPaths("admission_policy").build())
              .build();

      // Start a long-running operation (LRO).
      OperationFuture<AnywhereCache, UpdateAnywhereCacheMetadata> operation =
          storageControl.updateAnywhereCacheAsync(request);

      // Await the LROs completion.
      AnywhereCache updatedAnywhereCache = operation.get();
      System.out.printf("Updated anywhere cache: %s%n", updatedAnywhereCache.getName());
    }
  }
}

Rust

use google_cloud_lro::Poller;
use google_cloud_storage::client::StorageControl;
use google_cloud_storage::model::AnywhereCache;
use google_cloud_wkt::FieldMask;

pub async fn sample(
    client: &StorageControl,
    bucket_id: &str,
    cache_id: &str,
) -> anyhow::Result<()> {
    let anywhere_cache = AnywhereCache::new()
        .set_name(format!(
            "projects/_/buckets/{}/anywhereCaches/{}",
            bucket_id, cache_id
        ))
        .set_admission_policy("ADMIT_ON_SECOND_MISS".to_string());
    let operation = client
        .update_anywhere_cache()
        .set_anywhere_cache(anywhere_cache)
        .set_update_mask(FieldMask::default().set_paths(["admission_policy"]))
        .poller()
        .until_done()
        .await?;
    println!("Updated anywhere cache: {:?}", operation);
    Ok(())
}

Terraform

פרטים על השימוש ב-Rapid Cache עם Terraform זמינים בgoogle_storage_anywhere_cache מאמרי העזרה של Terraform.

ממשקי API ל-REST

‫API בפורמט JSON

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

  2. יוצרים קובץ JSON שכולל את השינויים שרוצים לבצע במאפייני המטמון.

    {
   "ttl": "TIME_TO_LIVE",
   "ingestOnWrite": INGEST_SETTING
}

    מחליפים את:

    • ‫TIME_TO_LIVE עם ה-TTL של הנתונים במטמון. הערך יכול להיות בין יום אחד ל-7 ימים, כולל. הערך יכול להיות בשניות, דקות, שעות וימים. לדוגמה:

      • ‫86400s למשך 86,400 שניות
      • ‫1440m למשך 1,440 דקות
      • ‫24h למשך 24 שעות
      • ‫1d ליום

    • ‫INGEST_SETTING עם true או false כדי לציין אם המטמון קולט נתונים בזמן הכתיבה.

    בדוגמה הבאה מעדכנים את ה-TTL של המטמון ליומיים:

    {
   "ttl": "172800s"
}

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

    curl -X PATCH --data-binary @JSON_FILE_NAME \
    -H "Authorization: Bearer $(gcloud auth print-access-token)" \
    -H "Content-Type: application/json" \
    "https://storage.googleapis.com/storage/v1/b/BUCKET_NAME/anywhereCaches/RAPID_CACHE_ID"

    מחליפים את:

    • ‫JSON_FILE_NAME בשם של קובץ ה-JSON שיצרתם בשלב 2.

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

    • ‫RAPID_CACHE_ID במזהה של המטמון. לדוגמה, us-east1-b.

אם הפעולה בוצעה ללא שגיאות, היא מחזירה google.longrunning.Operation. אפשר לקבל פרטים על הפעולה הממושכת.

המשך של מטמון

המסוף

כדי להפעיל מחדש מטמון שהושהה או הושבת:

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

    כניסה לדף Buckets

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

  3. בדף Bucket details, לוחצים על הכרטיסייה Configuration.

  4. בקטע Rapid Cache (שמירה מהירה במטמון), לוחצים על Manage caches (ניהול מטמונים).

  5. בחלונית ניהול מטמונים, לוחצים על סמל המשך המטמון ().

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

שורת הפקודה

משתמשים בפקודה gcloud storage buckets anywhere-caches resume:

gcloud storage buckets anywhere-caches resume CACHE_ID

מחליפים את:

  • ‫CACHE_ID עם המזהה של מופע הזיכרון למטמון, בנוסח הבא: BUCKET_NAME/CACHE_ZONE. לדוגמה, my-bucket/us-east1-b.

    כדי להפעיל מחדש כמה מטמונים בבת אחת, אפשר לציין כמה מזהים. לדוגמה, my-bucket/us-east1-b my-bucket/us-east1-c.

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

ספריות לקוח

C++

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

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

namespace storagecontrol = google::cloud::storagecontrol_v2;
[](storagecontrol::StorageControlClient client,
   std::string const& cache_name) {
  auto anywhere_cache = client.ResumeAnywhereCache(cache_name);
  if (!anywhere_cache) throw std::move(anywhere_cache).status();
  std::cout << "Resumed anywhere cache: " << anywhere_cache->name() << "\n";
}

Java

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

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


import com.google.storage.control.v2.AnywhereCache;
import com.google.storage.control.v2.ResumeAnywhereCacheRequest;
import com.google.storage.control.v2.StorageControlClient;
import java.io.IOException;

public final class AnywhereCacheResume {

  public static void anywhereCacheResume(String cacheName) throws IOException {
    try (StorageControlClient storageControl = StorageControlClient.create()) {

      ResumeAnywhereCacheRequest request =
          ResumeAnywhereCacheRequest.newBuilder().setName(cacheName).build();

      AnywhereCache anywhereCache = storageControl.resumeAnywhereCache(request);

      System.out.printf("Resumed anywhere cache: %s%n", anywhereCache.getName());
    }
  }
}

Rust

use google_cloud_storage::client::StorageControl;

pub async fn sample(
    client: &StorageControl,
    bucket_id: &str,
    cache_id: &str,
) -> anyhow::Result<()> {
    let cache = client
        .resume_anywhere_cache()
        .set_name(format!(
            "projects/_/buckets/{}/anywhereCaches/{}",
            bucket_id, cache_id
        ))
        .send()
        .await?;
    println!("Resumed anywhere cache: {:?}", cache);
    Ok(())
}

Terraform

פרטים על השימוש ב-Rapid Cache עם Terraform זמינים בgoogle_storage_anywhere_cache מאמרי העזרה של Terraform.

ממשקי API ל-REST

‫API בפורמט JSON

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

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

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

    מחליפים את:

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

    • ‫RAPID_CACHE_ID במזהה של המטמון. לדוגמה, us-east1-b.

אם הפעולה בוצעה ללא שגיאות, היא מחזירה משאב של AnywhereCache בפורמט.

השבתת מטמון

המסוף

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

    כניסה לדף Buckets

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

  3. בדף Bucket details, לוחצים על הכרטיסייה Configuration.

  4. בקטע Rapid Cache (מטמון מהיר), לוחצים על Manage caches (ניהול מטמונים).

  5. בחלונית ניהול מטמונים, לוחצים על סמל השבתת המטמון ().

  6. בתיבת הדו-שיח שמופיעה, לוחצים על Confirm.

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

שורת הפקודה

משתמשים בפקודה gcloud storage buckets anywhere-caches disable:

gcloud storage buckets anywhere-caches disable CACHE_ID

מחליפים את:

  • ‫CACHE_ID עם המזהה של מופע הזיכרון למטמון, בנוסח הבא: BUCKET_NAME/CACHE_ZONE. לדוגמה, my-bucket/us-east1-b.

    כדי להשבית כמה מטמונים בבת אחת, אפשר לציין כמה מזהים. לדוגמה, my-bucket/us-east1-b my-bucket/us-east1-c.

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

ספריות לקוח

C++

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

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

namespace storagecontrol = google::cloud::storagecontrol_v2;
[](storagecontrol::StorageControlClient client,
   std::string const& cache_name) {
  auto anywhere_cache = client.DisableAnywhereCache(cache_name);
  if (!anywhere_cache) throw std::move(anywhere_cache).status();
  std::cout << "Disabled anywhere cache: " << anywhere_cache->name() << "\n";
}

Java

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

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


import com.google.storage.control.v2.AnywhereCache;
import com.google.storage.control.v2.DisableAnywhereCacheRequest;
import com.google.storage.control.v2.StorageControlClient;
import java.io.IOException;

public final class AnywhereCacheDisable {

  public static void anywhereCacheDisable(String cacheName) throws IOException {
    try (StorageControlClient storageControl = StorageControlClient.create()) {

      DisableAnywhereCacheRequest request =
          DisableAnywhereCacheRequest.newBuilder().setName(cacheName).build();

      AnywhereCache anywhereCache = storageControl.disableAnywhereCache(request);

      System.out.printf("Disabled anywhere cache: %s%n", anywhereCache.getName());
    }
  }
}

Rust

use google_cloud_storage::client::StorageControl;

pub async fn sample(
    client: &StorageControl,
    bucket_id: &str,
    cache_id: &str,
) -> anyhow::Result<()> {
    let cache = client
        .disable_anywhere_cache()
        .set_name(format!(
            "projects/_/buckets/{}/anywhereCaches/{}",
            bucket_id, cache_id
        ))
        .send()
        .await?;
    println!("Disabled anywhere cache: {:?}", cache);
    Ok(())
}

Terraform

פרטים על השימוש ב-Rapid Cache עם Terraform זמינים בgoogle_storage_anywhere_cache מאמרי העזרה של Terraform.

ממשקי API ל-REST

‫API בפורמט JSON

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

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

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

    מחליפים את:

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

    • ‫RAPID_CACHE_ID במזהה של המטמון. לדוגמה, us-east1-b.

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

מעקב אחר ביצועי המטמון

החלק של Cloud Storage במסוף Google Cloud מספק תרשימי מעקב שמאפשרים לעקוב אחרי הביצועים של מטמון באמצעות מדדים. אפשר גם לראות את תרשימי המעקב האלה באמצעות Cloud Monitoring.

תרשימים זמינים

תרשים רמה בהיררכיית המשאבים תיאור
שיעור ההוצאה של בייטים מהזיכרון קטגוריה שיעור הבייטים שמוצאים מהמטמון, נדגמים כל שעה. הנתונים האלה מתעדכנים יותר מפעם בשעה כדי לאפשר זמן לעיבוד הנתונים אחרי שהם נאספים.
שיעור ההוצאה של בייטים מהזיכרון פרויקט שיעור הבייטים שמוצאים מכל המטמונים של דלי, בדגימה כל שעה. הנתונים האלה מתעדכנים יותר מפעם בשעה כדי לאפשר זמן לעיבוד הנתונים אחרי העיבוד הראשוני.
בייטים במטמון קטגוריה מספר הבייטים במטמון, נדגם כל שעה. הנתונים האלה מתעדכנים יותר מפעם בשעה כדי לאפשר זמן לעיבוד הנתונים אחרי העיבוד הראשוני.
בייטים במטמון פרויקט מספר הבייטים בכל המטמונים של קטגוריה, שנדגמים מדי שעה. הנתונים האלה מתעדכנים יותר מפעם בשעה כדי לאפשר זמן לעיבוד הנתונים אחרי השליחה.
היתרון של מטמון התפוקה פרויקט התעריף של מכסת רוחב הפס להעברת נתונים באזור, בשני אזורים או במספר אזורים, השימוש במכסה וקצב העברת הנתונים הנוסף שמוגש על ידי המטמון. התפוקה הנוספת שמתקבלת מהמטמון לא נספרת במכסה, ולכן השימוש במטמון מאפשר לפרויקטים לחרוג מהתפוקה שמותרת במסגרת המכסה.
פעולות של שיעור ההיטים קטגוריה אחוז הפעולות במטמון שבהן הנתונים המבוקשים מוגשים מהמטמון ביחס לסך כל הפעולות שעומדות בדרישות לשימוש במטמון. הנתונים נדגמים כל 60 שניות. אם פעולת קריאה מוחזרת לחלוטין מהמטמון, היא נחשבת כהצלחה. אם הקריאה לא מוחזרת מהמטמון או מוחזרת רק באופן חלקי מהמטמון, הפעולה נחשבת כהחמצה.
פעולות של שיעור ההיטים פרויקט אחוז הפעולות במטמון שמספקות את הנתונים המבוקשים מכל המטמונים של דלי, ביחס לסך כל הפעולות שמתאימות לאחסון במטמון. הנתונים נדגמים כל 60 שניות. אם פעולת קריאה מוחזרת לחלוטין מהמטמון, הפעולה נחשבת לפגיעה (hit). אם הקריאה לא מוחזרת מהמטמון או מוחזרת רק באופן חלקי מהמטמון, הפעולה נחשבת כהחמצה.
בייטים של שיעור ההיט קטגוריה אחוז הבייטים שמוצגים מהמטמון ביחס לסך הבייטים שניתנים לאחסון במטמון, נדגם כל 60 שניות.
בייטים של שיעור ההיט פרויקט אחוז הבייטים שמוצגים מכל המטמונים עבור דלי, ביחס לסך הבייטים שניתנים לאחסון במטמון, נדגמים כל 60 שניות.
שיעור הטמעת נתונים בבייטים גולמיים קטגוריה קצב הבייטים הגולמיים שמועברים לכל מטמון, שנדגמים כל 60 שניות. כל הבייטים שנקלטים, כולל בייטים שלא מחויבים, משמשים לחישוב הערך של המדד הזה. המדד הזה מדווח בזמן אמת.
שיעור הטמעת נתונים בבייטים גולמיים פרויקט קצב הבייטים הגולמיים שנקלטים בכל המטמונים של קטגוריה, שנדגמים כל 60 שניות. כל הבייטים שנקלטים, כולל בייטים שלא מחויבים, משמשים לחישוב הערך של המדד הזה. המדד הזה מדווח בזמן אמת.
Throughput - Cache hit קטגוריה התפוקה שמוצגת מהמטמון, שנדגמת כל 60 שניות.
Throughput - Cache hit פרויקט התפוקה שמוצגת מכל המטמונים עבור קטגוריה, שנדגמת כל 60 שניות.
Throughput - Cache miss קטגוריה התפוקה שלא מוגשת מהמטמון, שנדגמת כל 60 שניות.
Throughput - Cache miss פרויקט התפוקה שלא מוגשת מאף אחד מהמטמונים של מאגר, נדגמת כל 60 שניות.

תרשימי גישה

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

גישה לתרשימים ברמת הקטגוריה

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

    כניסה לדף Buckets

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

  3. בדף Bucket details, לוחצים על הכרטיסייה Observability.

  4. בתפריט הניווט, בוחרים באפשרות Rapid Cache.

    מוצגים תרשימי מעקב.

גישה לתרשימים ברמת הפרויקט

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

    כניסה לדף Buckets

  2. בחלונית הניווט Cloud Storage, לוחצים על Monitoring.

  3. בסרגל התפריטים, לוחצים על Rapid Cache.

    מוצגים תרשימי מעקב.

שימוש בפעולות ממושכות

כשמריצים בהצלחה את הפעולות AnywhereCaches Create ו-Update, מתחילה פעולה ממושכת. אתם יכולים לקבל ולרשום פעולות ממושכות כדי לראות את הפרטים והסטטוס של פעולת AnywhereCaches הבסיסית, או לבטל פעולה ממושכת כדי לבטל את פעולת AnywhereCaches הבסיסית בזמן שהיא מתבצעת.

הוראות לשימוש בפעולות ממושכות ב-Rapid Cache מפורטות במאמר בנושא שימוש בפעולות ממושכות.

בדוגמה הבאה מוצגת פעולה ממושכת שמופעלת מפעולת יצירה של AnywhereCaches:

done: false
kind: storage#operation
metadata:
  '@type': type.googleapis.com/google.storage.control.v2.CreateAnywhereCacheMetadata
  anywhereCacheId: us-central1-c
  zone: us-central1-c
  ttl: 172800s
  commonMetadata:
    createTime: '2023-12-14T20:52:00.032Z'
    progressPercent: -1
    requestedCancellation: false
    type: create-anywhere-cache
    updateTime: '2023-12-14T20:52:00.032Z'
name: projects/_/buckets/my-bucket/operations/AULf_KhQxxsWRSn56wv4jfmn3pOu_dKTz9FoYx6S0EzMw5ssR0cXIiorCvHRwqxZnQmWj9jnGpKb3Y6iCD3XM9KLc8EHBm7uig
selfLink: https://www.googleapis.com/storage/v1/b/my-bucket/operations/AULf_KhQxxsWRSn56wv4jfmn3pOu_dKTz9FoYx6S0EzMw5ssR0cXIiorCvHRwqxZnQmWj9jnGpKb3Y6iCD3XM9KLc8EHBm7uig

ניסיונות חוזרים

ממשקי ה-API האסינכרוניים של AnywhereCache הם אידמפוטנטיים כברירת מחדל. המשמעות היא שאתם יכולים לנסות שוב בבטחה קריאות אסינכרוניות ל-API של AnywhereCaches בלי לחשוש משינוי לא מכוון של משאבים.

לדוגמה, נניח שאתם מבצעים פעולת יצירה של AnywhereCaches כדי ליצור מטמון ב-us-central1-a, והפעולה מצליחה. אם מבצעים פעולת יצירה של AnywhereCaches באמצעות אותו אזור שמושלמת בהצלחה, הבקשה מחזירה את אותה פעולה ארוכת טווח כמו הבקשה הקודמת. שימו לב: ההתנהגות הזו מתרחשת רק אם כוללים request_id כחלק מהבקשה ליצירת מטמון. אם לא מציינים request_id, מקבלים שגיאת ANYWHERE_CACHE_ALREADY_EXISTS כשמנסים ליצור מטמון שכבר קיים. במאמר בנושא בקשה לזיהוי מוסבר איך לצרף request_id.

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

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