יצירה וניהול של מטמונים באמצעות 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 (נדרש לעדכון מטמונים)
  • ‫storage.managedFolders.create (נדרש רק כדי להפעיל את ההתנהגות של הטמעה בכתיבה במטמון)
  • storage.managedFolders.update (נדרש רק לעדכון ההתנהגות של הכנסת נתונים למטמון בזמן כתיבה)

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

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

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

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

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

יצירת מטמון

המסוף

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

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

    כניסה לדף Buckets

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

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

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

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

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

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

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

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

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

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

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

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

      1. בעמודה Ingestion criteria (קריטריונים להטמעה), לוחצים על Edit cache ingestion criteria (עריכת קריטריונים להטמעה של מטמון) עריכה.

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

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

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

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

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

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

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

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

  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 כדי לציין אם המטמון יקלוט נתונים בזמן הכתיבה.

      אם המדיניות מוגדרת לערך 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

פרטים על השימוש ב-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./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./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. בחלונית Set ingestion criteria (הגדרת קריטריונים להעברה):

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

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

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

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

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

  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 כדי לציין אם המטמון קולט נתונים בזמן הכתיבה.

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

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

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

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

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

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

      3. אם האפשרות ingest-on-write הופעלה בעבר עבור קידומת, קיימת תיקייה מנוהלת עם הגדרה 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 של המטמון ליומיים ומפעילים את התכונה 'הוספה בזמן כתיבה' לכל האובייקטים שנכתבים לקטגוריה:

    {
   "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. בחלונית ניהול מטמונים, לוחצים על סמל המשך המטמון ().

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

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

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

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