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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

הסבר על ההגדרות של הטמעה בזמן הכתיבה

כשיוצרים או מעדכנים מטמון, אפשר להפעיל את המטמון כדי להטמיע נתונים ברגע שהם נכתבים בקטגוריה. היכולת הזו נקראת ingest-on-write. אם אתם מתכננים להפעיל את התכונה "הטמעה בזמן כתיבה" באמצעות ה-API בפורמט JSON, מומלץ קודם להבין את ההתנהגות של ההגדרות שמשמשות להטמעה בזמן כתיבה.

יצירת מטמון

המסוף

יצירת מטמון לקטגוריה קיימת

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

    כניסה לדף Buckets

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

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

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

    הדף Configure cache מופיע בקטגוריה.

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

  6. בקטע Cache zones, בוחרים את האזורים שבהם רוצים ליצור מטמון. לכל מטמון שיוצרים באזור, אפשר לבצע את השלבים הבאים:

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

      כדי להגדיר TTL בהתאמה אישית:

      1. בעמודה Time to live, מציינים ערך של משך זמן (לדוגמה: 48) ויחידת זמן (לדוגמה: hours).

      2. לוחצים על שמירת ההגדרה.

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

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

      1. בעמודה Ingestion criteria, לוחצים על Edit cache ingestion criteria edit.

        מופיע הדף הגדרת קריטריונים להטמעה.

      2. מסמנים את התיבה הטמעת נתונים בזמן הכתיבה.

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

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

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

        כדי להסיר קידומת, לוחצים על מחיקת פריט delete.

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

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

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

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

יצירת מטמון לקטגוריה חדשה

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

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

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

    כניסה לדף Buckets

  2. לוחצים על הסמל View Column (), בוחרים באפשרות Cache ולוחצים על OK.

שורת הפקודה

משתמשים בפקודה 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 Create לפני שהיא מסתיימת.

ספריות לקוח

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

במאמרי העזרה של google_storage_anywhere_cache Terraform מוסבר איך משתמשים ב-Rapid 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) של הנתונים במטמון. הערך צריך להיות מוגדר בשניות (לדוגמה: 172800s ל-172,800 שניות, שהן יומיים).

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

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

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

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

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

      הפעלת הטמעה בזמן כתיבה בקטגוריה

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

      2. מבצעים את שלב 3 כדי להשלים את בקשת השמירה במטמון.

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

      1. מגדירים את הערך של INGEST_SETTINGS בתור false.

      2. מבצעים את שלב 3 כדי להשלים את בקשת השמירה במטמון.

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

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

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

      יצירת מטמון בלי להפעיל את האפשרות "הטמעה בזמן כתיבה"

      1. מגדירים את הערך של INGEST_SETTINGS בתור false.

      2. מבצעים את שלב 3 כדי להשלים את בקשת השמירה במטמון.

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

במאמרי העזרה של google_storage_anywhere_cache Terraform מוסבר איך משתמשים ב-Rapid 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./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

במאמרי העזרה של google_storage_anywhere_cache Terraform מוסבר איך משתמשים ב-Rapid 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./storage/v1/b/BUCKET_NAME/anywhereCaches"

    מחליפים את:

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

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

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

עדכון מטמון

המסוף

  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. בחלונית Set ingestion criteria:

      • כדי להפעיל או להשבית את האפשרות "הטמעה בזמן כתיבה", מסמנים את התיבה Ingest data on write או מבטלים את הסימון שלה, ואז לוחצים על Done.

      • כדי לעדכן את המטמון כך שיטמיע את כל האובייקטים בקטגוריה בזמן הכתיבה, מוודאים שתיבת הסימון Ingest data on write מסומנת ובוחרים באפשרות Entire bucket. אחר כך לוחצים על סיום.

      • כדי לעדכן את המטמון כך שיטמיע רק אובייקטים שמכילים קידומת מסוימת בשם שלהם, מוודאים שהתיבה Ingest data on write מסומנת ובוחרים באפשרות Selected folders.

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

        • כדי להסיר קידומת, לוחצים על מחיקת פריט לצד הקידומת.

  7. בדף Edit configuration, לוחצים על Save.

  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

במאמרי העזרה של google_storage_anywhere_cache Terraform מוסבר איך משתמשים ב-Rapid 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 כדי לציין אם המטמון מטמיע נתונים בזמן הכתיבה.

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

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

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

      הפעלת הטמעה בזמן כתיבה בקטגוריה

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

      2. מבצעים את שלב 3 כדי להשלים את בקשת השמירה במטמון.

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

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

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

      1. מגדירים את הערך של INGEST_SETTINGS בתור false.

      2. מבצעים את שלב 3 כדי להשלים את בקשת השמירה במטמון.

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

      4. שולחים בקשה לתיקייה מנוהלת PATCH שכוללת הגדרה של rapidCacheConfig. מגדירים את ערכי השדות בהגדרות האישיות לפי ההנחיות שבמאמר הגדרות והתנהגויות של הטמעה בזמן כתיבה.

      המפה policies של הגדרת rapidCacheConfig יכולה להכיל מזהה מטמון אחד או יותר (לדוגמה, us-east1-a ו-us-east1-b). כדי להפעיל את ההגדרה ingest-on-write במטמונים מסוימים, צריך להגדיר את ingestOnWrite של המטמון הספציפי ל-enabled. כדי להשבית את ההטמעה בזמן הכתיבה במטמונים מסוימים, מגדירים את ההגדרה ingestOnWrite של המטמון הספציפי לערך unspecified. כדאי לקרוא בעיון על הטמעה בירושה בזמן כתיבה כדי להבין איך מדיניות ההטמעה בזמן כתיבה של מטמון יכולה להיות מושפעת כשההגדרה ingestOnWrite של המטמון מוגדרת ל-unspecified.

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

      השבתת הטמעה בזמן כתיבה

      1. מגדירים את הערך של INGEST_SETTINGS בתור false. ההגדרה הזו משביתה את ההטמעה בזמן הכתיבה ברמת הקטגוריה.

      2. מבצעים את שלב 3 כדי להשלים את בקשת השמירה במטמון.

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

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

    בדוגמה הבאה מעדכנים את ה-TTL של המטמון ליומיים ומפעילים את ingest-on-write לכל האובייקטים שנכתבים בקטגוריה:

    {
   "ttl": "172800s",
   "ingestOnWrite": true
}

  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./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. בחלונית Manage caches, לוחצים על הסמל Resume cache ().

  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

במאמרי העזרה של google_storage_anywhere_cache Terraform מוסבר איך משתמשים ב-Rapid 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./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. בחלונית Manage caches, לוחצים על הסמל Disable cache ().

  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

במאמרי העזרה של google_storage_anywhere_cache Terraform מוסבר איך משתמשים ב-Rapid 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./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 שניות. אם פעולת קריאה מוחזרת במלואה מהמטמון, הפעולה נחשבת כהתאמה. אם פעולת הקריאה לא מוחזרת מהמטמון או מוחזרת ממנו באופן חלקי, הפעולה נחשבת כהחמצה.
בייטים של שיעור ההיטים קטגוריה אחוז הבייטים שמוצגים מהמטמון ביחס לסך הבייטים שמתאימים למטמון, שנדגמים כל 60 שניות.
בייטים של שיעור ההיטים פרויקט אחוז הבייטים שמוצגים מכל המטמונים של קטגוריה, ביחס לסך כל הבייטים שמתאימים למטמון, שנדגמים כל 60 שניות.
בייטים גולמיים של קצב הטמעת נתונים קטגוריה קצב הבייטים הגולמיים שנקלטו בכל מטמון, שנדגם כל 60 שניות. כל הבייטים שנקלטו, כולל בייטים שלא ניתנים לחיוב, משמשים לחישוב הערך של המדד הזה. המדד הזה מדווח בזמן אמת.
בייטים גולמיים של קצב הטמעת נתונים פרויקט קצב הבייטים הגולמיים שנקלטו בכל המטמונים של קטגוריה, נדגם כל 60 שניות. כל הבייטים שנקלטו, כולל בייטים שלא ניתנים לחיוב, משמשים לחישוב הערך של המדד הזה. המדד הזה מדווח בזמן אמת.
קצב העברת נתונים – מציאה במטמון (cache hit) קטגוריה קצב העברת הנתונים מהמטמון, שנדגם כל 60 שניות.
קצב העברת נתונים – מציאה במטמון (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 Create:

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 אסינכרוניים של AnywhereCaches הם אידמפוטנטיים כברירת מחדל. זה אומר שאפשר לנסות שוב בבטחה קריאות ל-API אסינכרוניות ל-AnywhereCaches בלי לחשוש משינוי משאבים באופן לא מכוון.

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

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

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