יצירה וניהול של מופעים

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

הערה: כדי להתנסות ב-Spanner באמצעות מכונה לתקופת ניסיון בחינם למשך 90 יום, קראו את המאמר יצירת מכונה לתקופת ניסיון בחינם ב-Spanner.

יצירת מכונה

אפשר ליצור מכונה באמצעות מסוף Google Cloud , Google Cloud CLI או ספריות לקוח. אפשר גם ליצור מכונה עם הגדרת מכונה בהתאמה אישית על ידי הוספת רפליקות לקריאה בלבד אופציונליות.

הערה: אין צורך להקצות נפח אחסון ב-Spanner, והחיוב הוא רק על נפח האחסון שבו משתמשים. מידע נוסף על מחירי האחסון

המסוף

1. נכנסים לדף Spanner Instances במסוף Google Cloud .

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

   כניסה לדף Create instance

3. בקטע Select an edition, בוחרים מהדורה של Spanner.

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

4. לוחצים על Continue.

5. בקטע Name your instance, מזינים את השם של המכונה (Instance name) שיוצג במסוף Google Cloud . שם המכונה חייב להיות ייחודי בפרויקט ב- Google Cloud .

6. מזינים מזהה מכונה כדי לזהות את המכונה באופן קבוע. מזהה המכונה חייב להיות ייחודי גם בפרויקט ב- Google Cloud . אי אפשר לשנות את מזהה המכונה בשלב מאוחר יותר.

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

8. בקטע Configure your instance, בקטע Choose a configuration, בוחרים באפשרות Regional,‏ בשני אזורים או במספר אזורים.

   הערה: הגדרות של מכונות בשני אזורים ובמספר אזורים זמינות רק במהדורת Enterprise Plus. אם רוצים להשוות בין המפרטים של שלוש ההגדרות, לוחצים על Compare region configurations.

9. בוחרים מיקום להגדרה מהתפריט הנפתח.

10. אופציונלי: כדי להוסיף רפליקה לקריאה בלבד להגדרת בסיס של Spanner, קודם צריך ליצור הגדרה מותאמת אישית של מכונה באמצעות ה-CLI של gcloud. אפשר להוסיף רפליקות אופציונליות לקריאה בלבד להגדרת בסיס במהדורות Enterprise ו-Enterprise Plus.

11. לוחצים על Continue.

12. בקטע Allocate compute capacity, בקטע Select unit, לוחצים על אחת מהאפשרויות הבאות:

    • צמתים למכונות גדולות. צומת הוא 1,000 יחידות עיבוד.
    • יחידות עיבוד למכונות קטנות.

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

13. בקטע Choose a scaling mode, לוחצים על אחת מהאפשרויות הבאות:

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

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

    • התאמה אוטומטית לעומס (scaling) כדי לאפשר ל-Spanner להוסיף ולהסיר באופן אוטומטי את קיבולת המחשוב. התכונה "ניהול התאמה אוטומטית לעומס" זמינה במהדורות Enterprise ו-Enterprise Plus של Spanner. למידע נוסף על הכלי המנוהל להתאמה אוטומטית לעומס, קראו את המאמר כלי מנוהל להתאמה אוטומטית לעומס ב-Spanner. מגדירים את האפשרויות הבאות של המידרוג האוטומטי המנוהל:

      • הערך Minimum מציין את הגבול המינימלי לצמצום אנכי בהתאם לעומס, בהתאם ליחידת המידה שבחרתם ל-Compute capacity. מידע נוסף זמין במאמר קביעת המגבלה המינימלית.
      • הערך של Maximum מציין את הגבול המקסימלי להגדלת קנה המידה, בהתאם ליחידת המידה שבחרתם ל-Compute capacity. מידע נוסף זמין במאמר קביעת המגבלה המקסימלית.
      • יעד ניצול המעבד (CPU) בעדיפות גבוהה מציין את אחוז היעד של המעבד (CPU) לשימוש במשימות בעדיפות גבוהה. למידע נוסף, קראו את המאמר הגדרת יעד לניצול ה-CPU.
      • Total CPU utilization target מציין את אחוז היעד של המעבד (CPU) שבו יש להשתמש לכל המשימות בעדיפות נמוכה, בינונית וגבוהה. מידע נוסף זמין במאמר הגדרת היעד הכולל של ניצול ה-CPU.
      • יעד ניצול נפח האחסון מציין את אחוז היעד של נפח האחסון לשימוש. מידע נוסף זמין במאמר הגדרת יעד ניצול נפח האחסון.

14. אופציונלי: אם בוחרים באפשרות Autoscaling כמצב ההתאמה לעומס, אפשר ללחוץ על התפריט הנפתח Show asymmetric autoscaling options כדי להתאים אוטומטית לעומס את הרפליקות לקריאה בלבד, בלי קשר לרפליקות אחרות. מידע נוסף מופיע במאמר התאמה אסימטרית של קנה המידה לקריאה בלבד.

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

    2. מגדירים את האפשרויות הבאות של התאמה אסימטרית לעומס:

       • הערך Minimum מציין את הגבול המינימלי לצמצום אנכי בהתאם לעומס, בהתאם ליחידת המידה שבחרתם ל-Compute capacity. מידע נוסף זמין במאמר קביעת המגבלה המינימלית.
       • הערך של Maximum מציין את הגבול המקסימלי להגדלת קנה המידה, בהתאם ליחידת המידה שבחרתם ל-Compute capacity. מידע נוסף זמין במאמר קביעת המגבלה המקסימלית.
       • High priority CPU utilization target מציין את אחוז היעד של המעבד (CPU) לשימוש במשימות בעדיפות גבוהה. למידע נוסף, קראו את המאמר קביעת היעד לניצול המעבד (CPU) בעדיפות גבוהה.
       • Total CPU utilization target מציין את אחוז היעד של ה-CPU שבו יש להשתמש לכל המשימות בעדיפות נמוכה, בינונית וגבוהה. אחוז המעבד יכול להיות בין 10% ל-90%. היעד הכולל של המעבד (CPU) צריך להיות גדול מהיעד של המעבד (CPU) בעדיפות גבוהה. אם אתם מבצעים אופטימיזציה לעלות, השתמשו באחוז גבוה יותר. למידע נוסף, ראו הגדרת היעד הכולל של ניצול ה-CPU.
       • Disable total CPU מציין שהמידרוג האוטומטי צריך להתעלם באופן מפורש מהיעד הכולל של המעבד (CPU).
       • השבתת מעבד בעדיפות גבוהה מציינת שהמידרוג האוטומטי צריך להתעלם באופן מפורש מיעד המעבד למשימות בעדיפות גבוהה.

15. בקטע Backups, התיבה Enable default backup schedules מסומנת כברירת מחדל. כדי להשבית את לוחות הזמנים של ברירת המחדל לגיבוי, מבטלים את הסימון בתיבה. כשההגדרה מופעלת, כל 24 שעות נוצרים גיבויים מלאים לכל מסדי הנתונים החדשים במכונה. הגיבויים האלה נשמרים למשך 7 ימים. אתם יכולים לערוך או למחוק את לוחות הזמנים של ברירת המחדל לגיבוי בכל שלב. מידע נוסף מופיע במאמר לוחות זמנים לגיבוי כברירת מחדל.

16. לוחצים על Create כדי ליצור את המכונה.

gcloud

משתמשים בפקודה gcloud spanner instances create כדי ליצור מכונה. מציינים את קיבולת המחשוב כמספר הצמתים או יחידות העיבוד שרוצים שיהיו במכונה.

gcloud spanner instances create INSTANCE_ID \
--edition=EDITION \
--config=INSTANCE_CONFIG \
--description=INSTANCE_DESCRIPTION \
--default-backup-schedule-type=DEFAULT_BACKUP_SCHEDULE_TYPE \
--nodes=NODE_COUNT

או

gcloud spanner instances create INSTANCE_ID \
--edition=EDITION \
--config=INSTANCE_CONFIG \
--description=INSTANCE_DESCRIPTION \
--default-backup-schedule-type=DEFAULT_BACKUP_SCHEDULE_TYPE \
--processing-units=PROCESSING_UNIT_COUNT

מחליפים את מה שכתוב בשדות הבאים:

• ‫INSTANCE-ID: מזהה קבוע וייחודי בפרויקט ב- Google Cloud . אי אפשר לשנות את מזהה המכונה בשלב מאוחר יותר.
• ‫INSTANCE-CONFIG: מזהה קבוע של הגדרת המכונה, שמגדיר את המיקום הגיאוגרפי של המכונה ומשפיע על אופן השכפול של הנתונים. במערכי הגדרות של מכונות בהתאמה אישית, הוא מתחיל ב-custom-. למידע נוסף, ראו הגדרות של מכונות.
• ‫INSTANCE_DESCRIPTION: השם שיוצג למכונה במסוף Google Cloud . שם המכונה חייב להיות ייחודי בפרויקט ב-Google Cloud .

• ‫DEFAULT_BACKUP_SCHEDULE_TYPE: סוג ברירת המחדל של תזמון הגיבוי שמשמש במכונה. צריך לציין אחד מהערכים הבאים:

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

• ‫NODE-COUNT: קיבולת המחשוב של המכונה, מבוטאת כמספר הצמתים. כל צומת שווה ל-1,000 יחידות עיבוד.

• ‫PROCESSING_UNIT_COUNT: קיבולת המחשוב של המכונה, מבוטאת כמספר יחידות עיבוד. כמויות של עד 1,000 צריך להזין בכפולות של 100 (100, 200, 300 וכן הלאה), וכמויות גדולות יותר צריך להזין בכפולות של 1,000 (1,000, 2,000, 3,000 וכן הלאה). הערה: אל תשתמשו בפרמטר הזה אם אתם יוצרים מכונה שאתם מתכוונים להפעיל בה את המידרוג האוטומטי המנוהל בשלב מאוחר יותר.

הוספת התאמה מנוהלת לעומס (autoscaling)

אתם יכולים גם ליצור מכונות במהדורת Enterprise ומהדורת Enterprise Plus כדי להשתמש בהתאמה מנוהלת לעומס באמצעות הפקודה gcloud spanner instances create. מידע נוסף זמין במאמר מידרוג אוטומטי מנוהל ל-Spanner.

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

  gcloud spanner instances create INSTANCE_ID \
    --edition=EDITION \
    --config=INSTANCE_CONFIG \
    --description=INSTANCE_DESCRIPTION \
    --autoscaling-min-processing-units=MINIMUM_PROCESSING_UNITS \
    --autoscaling-max-processing-units=MAXIMUM_PROCESSING_UNITS \
    --autoscaling-high-priority-cpu-target=HIGH_PRIORITY_CPU_PERCENTAGE \
    --autoscaling-total-cpu-target=TOTAL_CPU_PERCENTAGE \
    --autoscaling-storage-target=STORAGE_PERCENTAGE \
    [--disable-downscaling | --no-disable-downscaling] \
    [--asymmetric-autoscaling-option \
       location=ASYMMETRIC_AUTOSCALING_LOCATION,\
       min_nodes=ASYMMETRIC_AUTOSCALING_MIN,\
       max_nodes=ASYMMETRIC_AUTOSCALING_MAX,\
       high_priority_cpu_target=ASYMMETRIC_HIGH_PRIORITY_CPU_TARGET,\
       total_cpu_target=ASYMMETRIC_TOTAL_CPU_TARGET \
       [,disable_total_cpu_autoscaling=TRUE|FALSE \
       | disable_high_priority_cpu_autoscaling=TRUE|FALSE]
    ]

או

  gcloud spanner instances create INSTANCE_ID \
    --edition=EDITION \
    --config=INSTANCE_CONFIG \
    --description=INSTANCE_DESCRIPTION \
    --autoscaling-min-nodes=MINIMUM_NODES \
    --autoscaling-max-nodes=MAXIMUM_NODES \
    --autoscaling-high-priority-cpu-target=HIGH_PRIORITY_CPU_PERCENTAGE \
    --autoscaling-total-cpu-target=TOTAL_CPU_PERCENTAGE \
    --autoscaling-storage-target=STORAGE_PERCENTAGE \
    [--disable-downscaling | --no-disable-downscaling] \
    [--asymmetric-autoscaling-option \
       location=ASYMMETRIC_AUTOSCALING_LOCATION,\
       min_nodes=ASYMMETRIC_AUTOSCALING_MIN,\
       max_nodes=ASYMMETRIC_AUTOSCALING_MAX,\
       high_priority_cpu_target=ASYMMETRIC_HIGH_PRIORITY_CPU_TARGET, \
       total_cpu_target=ASYMMETRIC_TOTAL_CPU_TARGET, \
       [,disable_total_cpu_autoscaling=TRUE|FALSE \
       | disable_high_priority_cpu_autoscaling=TRUE|FALSE]
    ]

מחליפים את מה שכתוב בשדות הבאים:

• ‫INSTANCE-ID: מזהה קבוע וייחודי בפרויקט ב- Google Cloud . אי אפשר לשנות את מזהה המכונה בשלב מאוחר יותר.
• ‫INSTANCE-CONFIG: מזהה קבוע של הגדרת המכונה, שמגדיר את המיקום הגיאוגרפי של המכונה ומשפיע על אופן השכפול של הנתונים. במערכי הגדרות של מכונות בהתאמה אישית, הוא מתחיל ב-custom-. למידע נוסף, ראו הגדרות של מכונות.
• ‫INSTANCE-DESCRIPTION: השם שיוצג למכונה במסוף Google Cloud . שם המכונה חייב להיות ייחודי בפרויקט ב-Google Cloud .
• ‫MINIMUM_PROCESSING_UNITS, MINIMUM_NODES: המספר המינימלי של יחידות עיבוד או צמתים כשמצמצמים אנכית בהתאם לעומס (scale down). מידע נוסף מופיע בקטע קביעת המגבלה המינימלית.
• ‫MAXIMUM_PROCESSING_UNITS, MAXIMUM_NODES: המספר המקסימלי של יחידות עיבוד או צמתים בהגדלת קנה המידה. מידע נוסף מופיע במאמר קביעת המגבלה המקסימלית.
• ‫HIGH_PRIORITY_CPU_PERCENTAGE: אחוז היעד של שימוש במעבד (CPU) בעדיפות גבוהה, על סמך עדיפות המשימה. אחוז המעבד יכול להיות בין 10% ל-90%. אם אתם מבצעים אופטימיזציה לעלות, השתמשו באחוז גבוה יותר. למידע נוסף, קראו את המאמר קביעת היעד לניצול המעבד (CPU) בעדיפות גבוהה.
• ‫TOTAL_CPU_PERCENTAGE: אחוז היעד של סך כל המעבד (CPU) בעדיפות גבוהה שבו צריך להשתמש. יעד המעבד (CPU) הכולל צריך להיות גדול מיעד המעבד (CPU) בעדיפות גבוהה. אחוז המעבד יכול להיות בין 10% ל-90%. אם אתם מבצעים אופטימיזציה לעלות, השתמשו באחוז גבוה יותר. למידע נוסף, קראו את המאמר קביעת היעד הכולל של ניצול ה-CPU.
• ‫STORAGE_PERCENTAGE: אחוז היעד של נפח האחסון לשימוש, מ-10% עד 99%. מידע נוסף זמין במאמר הגדרת יעד לניצול נפח האחסון.

דגלים אופציונליים:

• ‫--disable-downscaling: משתמשים בדגל הבוליאני הזה כדי להשבית את הקטנת קנה המידה. כשהערך מוגדר כ-TRUE, המידרוג האוטומטי לא יכול להקטין את מספר הצמתים או יחידות העיבוד. הגדלת המכסות ממשיכה לפעול כרגיל כדי לעמוד בביקוש הגובר. כדי להפעיל את הקטנת קנה המידה אחרי שהשבתתם אותה, משתמשים בדגל --no-disable-downscaling.

• ‫--asymmetric-autoscaling-option: משתמשים בדגל הזה כדי להפעיל התאמה אסימטרית לעומס (autoscaling). מחליפים את הפרמטרים הבאים:

  • ‫ASYMMETRIC_AUTOSCALING_LOCATION: אם משתמשים בדגל, חובה להשתמש בפרמטר הזה. המיקום של האזור לקריאה בלבד שרוצים לשנות את הגודל שלו באופן אסימטרי.
  • ‫ASYMMETRIC_AUTOSCALING_MIN: פרמטר אופציונלי. מספר הצמתים המינימלי כשמצמצמים את קנה המידה. אם לא מציינים את הערך הזה, הוא עובר בירושה מהגדרת המכונה הבסיסית.
  • ‫ASYMMETRIC_AUTOSCALING_MAX: פרמטר אופציונלי. מספר הצמתים המקסימלי בהגדלת קנה המידה. אם לא מציינים את הערך הזה, הוא עובר בירושה מהגדרת המכונה הבסיסית.
  • ‫ASYMMETRIC_HIGH_PRIORITY_CPU_TARGET: פרמטר אופציונלי. אחוז היעד של המעבד (CPU) לשימוש, על סמך עדיפות המשימה. אם לא מציינים ערך, הוא עובר בירושה מהגדרת המכונה הבסיסית. אם אתם מבצעים אופטימיזציה לעלות, השתמשו באחוז גבוה יותר. לרפליקות יכול להיות אחוז יעד שונה מזה של המכונה הבסיסית ומרפליקות אחרות, אבל בתרחישים של יתירות כשל, מומלץ להשתמש ביעדים עקביים ברפליקות השונות. מידע נוסף זמין במאמר בעיות שקשורות ליתירות כשל.
  • ‫ASYMMETRIC_TOTAL_CPU_TARGET: פרמטר אופציונלי. מגדירים את היעד מ-10% עד 90% ל-total CPU. אם לא מציינים ערך, הוא עובר בירושה מהגדרת המכונה הבסיסית. אם אתם מבצעים אופטימיזציה לעלות, השתמשו באחוז גבוה יותר. לרפליקות יכול להיות אחוז יעד שונה מזה של המכונה הבסיסית ומרפליקות אחרות, אבל בתרחישים של יתירות כשל, מומלץ להשתמש ביעדים עקביים ברפליקות השונות. מידע נוסף זמין במאמר התאמה אסימטרית לקריאה בלבד של קנה המידה.
  • ‫disable_total_cpu_autoscaling: מגדירים את הפרמטר הזה לערך TRUE אם לא רוצים שהמנגנון להתאמה אוטומטית של קנה המידה יתאים אוטומטית את קנה המידה של סך כל ה-CPU ברפליקות. אם רוצים שהמכונה תירש את היעד total_cpu_autoscaling ממכונת הבסיס, לא צריך לציין את הפרמטר הזה. אי אפשר להשבית גם את סך כל המעבד (CPU) וגם את המעבד (CPU) בעדיפות גבוהה באותה רפליקה.
  • ‫disable_high_priority_cpu_autoscaling: מגדירים את disable_high_priority_cpu_autoscaling לערך TRUE אם לא רוצים שה-autoscaler ישנה את הגודל של ה-CPU בעדיפות גבוהה ברפליקות. אם רוצים שהמכונה תירש את היעד high_priority_cpu_autoscaling ממכונת הבסיס, לא צריך לציין את הפרמטר הזה. אי אפשר להשבית גם את סך כל המעבד (CPU) וגם את המעבד (CPU) בעדיפות גבוהה באותה רפליקה.

דוגמאות לשימוש בהגדרות אישיות

כדי ליצור מכונה test-instance בהגדרת המכונה האזורית הבסיסית us-central1, מריצים את הפקודה:

gcloud spanner instances create test-instance --edition=STANDARD --config=regional-us-central1 \
  --description="Test Instance" --nodes=1

כדי ליצור מכונה custom-eur6-instance בהגדרת המכונה custom-eur6 במספר אזורים בהתאמה אישית, קודם צריך ליצור הגדרת מכונה בהתאמה אישית.

לאחר מכן, מריצים את הפקודה:

  gcloud spanner instances create custom-eur6-instance --edition=ENTERPRISE_PLUS --config=custom-eur6 \
      --description="Instance with custom read-only" --nodes=1

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

Creating instance...done.

C++‎

במאמר ספריות הלקוח של Spanner מוסבר איך להתקין את ספריית הלקוח ולהשתמש בה ב-Spanner.

כדי לבצע אימות ב-Spanner, צריך להגדיר את Application Default Credentials. למידע נוסף, ראו הגדרת אימות לסביבת פיתוח מקומית.

void CreateInstance(google::cloud::spanner_admin::InstanceAdminClient client,
                    std::string const& project_id,
                    std::string const& instance_id,
                    std::string const& display_name,
                    std::string const& config_id) {
  namespace spanner = ::google::cloud::spanner;
  spanner::Instance in(project_id, instance_id);

  auto project = google::cloud::Project(project_id);
  std::string config_name =
      project.FullName() + "/instanceConfigs/" + config_id;
  auto instance =
      client
          .CreateInstance(spanner::CreateInstanceRequestBuilder(in, config_name)
                              .SetDisplayName(display_name)
                              .SetNodeCount(1)
                              .SetLabels({{"cloud_spanner_samples", "true"}})
                              .Build())
          .get();
  if (!instance) throw std::move(instance).status();
  std::cout << "Created instance [" << in << "]:\n" << instance->DebugString();
}

C#‎

במאמר ספריות הלקוח של Spanner מוסבר איך להתקין את ספריית הלקוח ולהשתמש בה ב-Spanner.

כדי לבצע אימות ב-Spanner, צריך להגדיר את Application Default Credentials. למידע נוסף, ראו הגדרת אימות לסביבת פיתוח מקומית.

using Google.Api.Gax.ResourceNames;
using Google.Cloud.Spanner.Admin.Instance.V1;
using Google.Cloud.Spanner.Common.V1;
using Google.LongRunning;
using System;
using System.Threading.Tasks;

public class CreateInstanceAsyncSample
{
    public async Task<Instance> CreateInstanceAsync(
        string projectId,
        string instanceId,
        Instance.Types.Edition edition = Instance.Types.Edition.Standard)
    {
        // Create the InstanceAdminClient instance.
        InstanceAdminClient instanceAdminClient = await InstanceAdminClient.CreateAsync();

        // Initialize request parameters.
        Instance instance = new Instance
        {
            InstanceName = InstanceName.FromProjectInstance(projectId, instanceId),
            ConfigAsInstanceConfigName = InstanceConfigName.FromProjectInstanceConfig(projectId, "regional-us-central1"),
            DisplayName = "This is a display name.",
            NodeCount = 1,
            Labels =
            {
                { "cloud_spanner_samples", "true" },
            },
            Edition = edition,
        };
        ProjectName projectName = ProjectName.FromProject(projectId);

        // Make the CreateInstance request.
        Operation<Instance, CreateInstanceMetadata> response = await instanceAdminClient.CreateInstanceAsync(projectName, instanceId, instance);

        Console.WriteLine("Waiting for the operation to finish.");

        // Poll until the returned long-running operation is complete.
        Operation<Instance, CreateInstanceMetadata> completedResponse = await response.PollUntilCompletedAsync();

        if (completedResponse.IsFaulted)
        {
            Console.WriteLine($"Error while creating instance: {completedResponse.Exception}");
            throw completedResponse.Exception;
        }

        Console.WriteLine($"Instance created successfully.");

        return completedResponse.Result;
    }
}

יצירת מכונה בלי לוח זמנים לגיבוי כברירת מחדל

using Google.Api.Gax.ResourceNames;
using Google.Cloud.Spanner.Admin.Instance.V1;
using Google.Cloud.Spanner.Common.V1;
using Google.LongRunning;
using System;
using System.Threading.Tasks;

public class CreateInstanceWithoutDefaultBackupSchedulesAsyncSample
{
    public async Task<Instance> CreateInstanceWithoutDefaultBackupSchedulesAsync(string projectId, string instanceId)
    {
        // Create the InstanceAdminClient instance.
        InstanceAdminClient instanceAdminClient = await InstanceAdminClient.CreateAsync();

        // Initialize request parameters.
        Instance instance = new Instance
        {
            InstanceName = InstanceName.FromProjectInstance(projectId, instanceId),
            ConfigAsInstanceConfigName =
                InstanceConfigName.FromProjectInstanceConfig(projectId, "regional-me-central2"),
            DisplayName = "This is a display name.",
            NodeCount = 1,
            Labels =
            {
                { "cloud_spanner_samples", "true" },
            },
            DefaultBackupScheduleType = Instance.Types.DefaultBackupScheduleType.None,
        };
        ProjectName projectName = ProjectName.FromProject(projectId);

        // Make the CreateInstance request.
        Operation<Instance, CreateInstanceMetadata> response =
            await instanceAdminClient.CreateInstanceAsync(projectName, instanceId, instance);

        Console.WriteLine("Waiting for the operation to finish.");

        // Poll until the returned long-running operation is complete.
        Operation<Instance, CreateInstanceMetadata> completedResponse =
            await response.PollUntilCompletedAsync();

        if (completedResponse.IsFaulted)
        {
            Console.WriteLine($"Error while creating instance: {completedResponse.Exception}");
            throw completedResponse.Exception;
        }

        Console.WriteLine($"Instance created successfully.");
        return completedResponse.Result;
    }
}

המשך

במאמר ספריות הלקוח של Spanner מוסבר איך להתקין את ספריית הלקוח ולהשתמש בה ב-Spanner.

כדי לבצע אימות ב-Spanner, צריך להגדיר את Application Default Credentials. למידע נוסף, ראו הגדרת אימות לסביבת פיתוח מקומית.

import (
	"context"
	"fmt"
	"io"

	instance "cloud.google.com/go/spanner/admin/instance/apiv1"
	"cloud.google.com/go/spanner/admin/instance/apiv1/instancepb"
)

func createInstance(w io.Writer, projectID, instanceID string) error {
	// projectID := "my-project-id"
	// instanceID := "my-instance"
	ctx := context.Background()
	instanceAdmin, err := instance.NewInstanceAdminClient(ctx)
	if err != nil {
		return err
	}
	defer instanceAdmin.Close()

	op, err := instanceAdmin.CreateInstance(ctx, &instancepb.CreateInstanceRequest{
		Parent:     fmt.Sprintf("projects/%s", projectID),
		InstanceId: instanceID,
		Instance: &instancepb.Instance{
			Config:      fmt.Sprintf("projects/%s/instanceConfigs/%s", projectID, "regional-us-central1"),
			DisplayName: instanceID,
			NodeCount:   1,
			Labels:      map[string]string{"cloud_spanner_samples": "true"},
			Edition:     instancepb.Instance_STANDARD,
		},
	})
	if err != nil {
		return fmt.Errorf("could not create instance %s: %w", fmt.Sprintf("projects/%s/instances/%s", projectID, instanceID), err)
	}
	// Wait for the instance creation to finish.
	i, err := op.Wait(ctx)
	if err != nil {
		return fmt.Errorf("waiting for instance creation to finish failed: %w", err)
	}
	// The instance may not be ready to serve yet.
	if i.State != instancepb.Instance_READY {
		fmt.Fprintf(w, "instance state is not READY yet. Got state %v\n", i.State)
	}
	fmt.Fprintf(w, "Created instance [%s]\n", instanceID)
	return nil
}

יצירת מכונה עם התאמה אוטומטית לעומס (automatic scaling) מנוהלת באמצעות Go

import (
	"context"
	"fmt"
	"io"

	instance "cloud.google.com/go/spanner/admin/instance/apiv1"
	"cloud.google.com/go/spanner/admin/instance/apiv1/instancepb"
	"google.golang.org/genproto/protobuf/field_mask"
)

// Example of creating an autoscaling instance with Go.
// projectID is the ID of the project that the new instance will be in.
// instanceID is the ID of the new instance to be created.
func createInstanceWithAutoscalingConfig(w io.Writer, projectID, instanceID string) error {
	// projectID := "my-project-id"
	// instanceID := "my-instance"
	ctx := context.Background()
	instanceAdmin, err := instance.NewInstanceAdminClient(ctx)
	if err != nil {
		return fmt.Errorf("could not create instance admin client for project %s: %w", projectID, err)
	}
	defer instanceAdmin.Close()

	instanceName := fmt.Sprintf("projects/%s/instances/%s", projectID, instanceID)
	fmt.Fprintf(w, "Creating instance %s.", instanceName)

	op, err := instanceAdmin.CreateInstance(ctx, &instancepb.CreateInstanceRequest{
		Parent:     fmt.Sprintf("projects/%s", projectID),
		InstanceId: instanceID,
		Instance: &instancepb.Instance{
			Config:      fmt.Sprintf("projects/%s/instanceConfigs/%s", projectID, "regional-us-central1"),
			DisplayName: "Create instance example",
			AutoscalingConfig: &instancepb.AutoscalingConfig{
				AutoscalingLimits: &instancepb.AutoscalingConfig_AutoscalingLimits{
					MinLimit: &instancepb.AutoscalingConfig_AutoscalingLimits_MinNodes{
						MinNodes: 1,
					},
					MaxLimit: &instancepb.AutoscalingConfig_AutoscalingLimits_MaxNodes{
						MaxNodes: 2,
					},
				},
				AutoscalingTargets: &instancepb.AutoscalingConfig_AutoscalingTargets{
					HighPriorityCpuUtilizationPercent: 65,
					StorageUtilizationPercent:         95,
				},
			},
			Labels:  map[string]string{"cloud_spanner_samples": "true"},
			Edition: instancepb.Instance_ENTERPRISE_PLUS,
		},
	})
	if err != nil {
		return fmt.Errorf("could not create instance %s: %w", instanceName, err)
	}
	fmt.Fprintf(w, "Waiting for operation on %s to complete...", instanceID)
	// Wait for the instance creation to finish.
	i, err := op.Wait(ctx)
	if err != nil {
		return fmt.Errorf("waiting for instance creation to finish failed: %w", err)
	}
	// The instance may not be ready to serve yet.
	if i.State != instancepb.Instance_READY {
		fmt.Fprintf(w, "instance state is not READY yet. Got state %v\n", i.State)
	}
	fmt.Fprintf(w, "Created instance [%s].\n", instanceID)

	instance, err := instanceAdmin.GetInstance(ctx, &instancepb.GetInstanceRequest{
		Name: instanceName,
		// Get the autoscaling_config field from the newly created instance.
		FieldMask: &field_mask.FieldMask{Paths: []string{"autoscaling_config"}},
	})
	if err != nil {
		return fmt.Errorf("failed to get instance [%s]: %w", instanceName, err)
	}
	fmt.Fprintf(w, "Instance %s has autoscaling_config: %s.", instanceID, instance.AutoscalingConfig)
	return nil
}

יצירת מכונה עם התאמה אסימטרית לקריאה בלבד באמצעות Go

import (
	"context"
	"fmt"
	"io"

	instance "cloud.google.com/go/spanner/admin/instance/apiv1"
	"cloud.google.com/go/spanner/admin/instance/apiv1/instancepb"
	"google.golang.org/genproto/protobuf/field_mask"
)

// createInstanceWithAsymmetricAutoscalingConfig is a code snippet to show
// an example of creating an asymmetric autoscaling enabled instance in Go.
//
// projectID is the ID of the project that the new instance will be in.
// instanceID is the ID of the new instance to be created.
func createInstanceWithAsymmetricAutoscalingConfig(w io.Writer, projectID, instanceID string) error {
	ctx := context.Background()
	instanceAdmin, err := instance.NewInstanceAdminClient(ctx)
	if err != nil {
		return fmt.Errorf("could not create instance admin client for project %s: %w", projectID, err)
	}
	defer instanceAdmin.Close()

	instanceName := fmt.Sprintf("projects/%s/instances/%s", projectID, instanceID)
	fmt.Fprintf(w, "Creating instance %s.", instanceName)

	op, err := instanceAdmin.CreateInstance(ctx, &instancepb.CreateInstanceRequest{
		Parent:     fmt.Sprintf("projects/%s", projectID),
		InstanceId: instanceID,
		Instance: &instancepb.Instance{
			Config:      fmt.Sprintf("projects/%s/instanceConfigs/%s", projectID, "nam-eur-asia3"),
			DisplayName: "Create instance example",
			AutoscalingConfig: &instancepb.AutoscalingConfig{
				AutoscalingLimits: &instancepb.AutoscalingConfig_AutoscalingLimits{
					MinLimit: &instancepb.AutoscalingConfig_AutoscalingLimits_MinNodes{
						MinNodes: 1,
					},
					MaxLimit: &instancepb.AutoscalingConfig_AutoscalingLimits_MaxNodes{
						MaxNodes: 10,
					},
				},
				AutoscalingTargets: &instancepb.AutoscalingConfig_AutoscalingTargets{
					HighPriorityCpuUtilizationPercent: 65,
					StorageUtilizationPercent:         95,
				},
				// Read-only replicas in europe-west1, europe-west4, and asia-east1 are autoscaled
				// independly from other replicas based on the usage in the respective region.
				AsymmetricAutoscalingOptions: []*instancepb.AutoscalingConfig_AsymmetricAutoscalingOption{
					&instancepb.AutoscalingConfig_AsymmetricAutoscalingOption{
						ReplicaSelection: &instancepb.ReplicaSelection{
							Location: "europe-west1",
						},
					},
					&instancepb.AutoscalingConfig_AsymmetricAutoscalingOption{
						ReplicaSelection: &instancepb.ReplicaSelection{
							Location: "europe-west4",
						},
					},
					&instancepb.AutoscalingConfig_AsymmetricAutoscalingOption{
						ReplicaSelection: &instancepb.ReplicaSelection{
							Location: "asia-east1",
						},
					},
				},
			},
			Labels:  map[string]string{"cloud_spanner_samples": "true"},
			Edition: instancepb.Instance_ENTERPRISE_PLUS,
		},
	})
	if err != nil {
		return fmt.Errorf("could not create instance %s: %w", instanceName, err)
	}
	fmt.Fprintf(w, "Waiting for operation on %s to complete...", instanceID)
	// Wait for the instance creation to finish.
	i, err := op.Wait(ctx)
	if err != nil {
		return fmt.Errorf("waiting for instance creation to finish failed: %w", err)
	}
	// The instance may not be ready to serve yet.
	if i.State != instancepb.Instance_READY {
		fmt.Fprintf(w, "instance state is not READY yet. Got state %v\n", i.State)
	}
	fmt.Fprintf(w, "Created instance [%s].\n", instanceID)

	instance, err := instanceAdmin.GetInstance(ctx, &instancepb.GetInstanceRequest{
		Name: instanceName,
		// Get the autoscaling_config field from the newly created instance.
		FieldMask: &field_mask.FieldMask{Paths: []string{"autoscaling_config"}},
	})
	if err != nil {
		return fmt.Errorf("failed to get instance [%s]: %w", instanceName, err)
	}
	fmt.Fprintf(w, "Instance %s has autoscaling_config: %s.", instanceID, instance.AutoscalingConfig)
	return nil
}

יצירת מכונה בלי תזמון גיבוי כברירת מחדל

import (
	"context"
	"fmt"
	"io"

	instance "cloud.google.com/go/spanner/admin/instance/apiv1"
	"cloud.google.com/go/spanner/admin/instance/apiv1/instancepb"
)

// createInstanceWithoutDefaultBackupSchedule creates instance with default backup schedule disabled.
func createInstanceWithoutDefaultBackupSchedule(w io.Writer, projectID, instanceID string) error {
	// projectID := "my-project-id"
	// instanceID := "my-instance"
	ctx := context.Background()
	instanceAdmin, err := instance.NewInstanceAdminClient(ctx)
	if err != nil {
		return err
	}
	defer instanceAdmin.Close()

	// Create an instance without default backup schedule, whicn means no default backup schedule will
	// be created automatically on creation of a database within the instance.
	req := &instancepb.CreateInstanceRequest{
		Parent:     fmt.Sprintf("projects/%s", projectID),
		InstanceId: instanceID,
		Instance: &instancepb.Instance{
			Config:                    fmt.Sprintf("projects/%s/instanceConfigs/%s", projectID, "regional-us-central1"),
			DisplayName:               instanceID,
			NodeCount:                 1,
			Labels:                    map[string]string{"cloud_spanner_samples": "true"},
			DefaultBackupScheduleType: instancepb.Instance_NONE,
		},
	}

	op, err := instanceAdmin.CreateInstance(ctx, req)
	if err != nil {
		return fmt.Errorf("could not create instance %s: %w", fmt.Sprintf("projects/%s/instances/%s", projectID, instanceID), err)
	}
	// Wait for the instance creation to finish.  For more information about instances, see
	// https://cloud.google.com/spanner/docs/instances.
	instance, err := op.Wait(ctx)
	if err != nil {
		return fmt.Errorf("waiting for instance creation to finish failed: %w", err)
	}
	// The instance may not be ready to serve yet.
	if instance.State != instancepb.Instance_READY {
		fmt.Fprintf(w, "instance state is not READY yet. Got state %v\n", instance.State)
	}
	fmt.Fprintf(w, "Created instance [%s]\n", instanceID)
	return nil
}

Java

במאמר ספריות הלקוח של Spanner מוסבר איך להתקין את ספריית הלקוח ולהשתמש בה ב-Spanner.

כדי לבצע אימות ב-Spanner, צריך להגדיר את Application Default Credentials. למידע נוסף, ראו הגדרת אימות לסביבת פיתוח מקומית.

import com.google.cloud.spanner.Spanner;
import com.google.cloud.spanner.SpannerOptions;
import com.google.cloud.spanner.admin.instance.v1.InstanceAdminClient;
import com.google.spanner.admin.instance.v1.CreateInstanceRequest;
import com.google.spanner.admin.instance.v1.Instance;
import com.google.spanner.admin.instance.v1.InstanceConfigName;
import com.google.spanner.admin.instance.v1.ProjectName;
import java.util.concurrent.ExecutionException;

class CreateInstanceExample {

  static void createInstance() {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "my-project";
    String instanceId = "my-instance";
    createInstance(projectId, instanceId);
  }

  static void createInstance(String projectId, String instanceId) {
    // Set Instance configuration.
    int nodeCount = 2;
    String displayName = "Descriptive name";

    // Create an Instance object that will be used to create the instance.
    Instance instance =
        Instance.newBuilder()
            .setDisplayName(displayName)
            .setEdition(Instance.Edition.STANDARD)
            .setNodeCount(nodeCount)
            .setConfig(InstanceConfigName.of(projectId, "regional-us-east4").toString())
            .build();

    try (Spanner spanner =
            SpannerOptions.newBuilder().setProjectId(projectId).build().getService();
        InstanceAdminClient instanceAdminClient = spanner.createInstanceAdminClient()) {

      // Wait for the createInstance operation to finish.
      Instance createdInstance =
          instanceAdminClient
              .createInstanceAsync(
                  CreateInstanceRequest.newBuilder()
                      .setParent(ProjectName.of(projectId).toString())
                      .setInstanceId(instanceId)
                      .setInstance(instance)
                      .build())
              .get();
      System.out.printf("Instance %s was successfully created%n", createdInstance.getName());
    } catch (ExecutionException e) {
      System.out.printf(
          "Error: Creating instance %s failed with error message %s%n",
          instance.getName(), e.getMessage());
    } catch (InterruptedException e) {
      System.out.println("Error: Waiting for createInstance operation to finish was interrupted");
    }
  }
}

יצירת מכונה עם התאמה אוטומטית מנוהלת לעומס (autoscaling) באמצעות Java

import com.google.cloud.spanner.Spanner;
import com.google.cloud.spanner.SpannerOptions;
import com.google.cloud.spanner.admin.instance.v1.InstanceAdminClient;
import com.google.spanner.admin.instance.v1.AutoscalingConfig;
import com.google.spanner.admin.instance.v1.CreateInstanceRequest;
import com.google.spanner.admin.instance.v1.Instance;
import com.google.spanner.admin.instance.v1.InstanceConfigName;
import com.google.spanner.admin.instance.v1.ProjectName;
import com.google.spanner.admin.instance.v1.ReplicaSelection;
import java.util.concurrent.ExecutionException;

class CreateInstanceWithAsymmetricAutoscalingConfigExample {

  static void createInstance() {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "my-project";
    String instanceId = "my-instance";
    createInstance(projectId, instanceId);
  }

  static void createInstance(String projectId, String instanceId) {
    try (Spanner spanner =
        SpannerOptions.newBuilder()
            .setProjectId(projectId)
            .build()
            .getService();
        InstanceAdminClient instanceAdminClient = spanner.createInstanceAdminClient()) {
      // Set Instance configuration.
      String configId = "nam-eur-asia3";
      String displayName = "Descriptive name";

      // Create an autoscaling config.
      // When autoscaling_config is enabled, node_count and processing_units fields
      // need not be specified.
      // The read-only replicas listed in the asymmetric autoscaling options scale independently
      // from other replicas.
      AutoscalingConfig autoscalingConfig =
          AutoscalingConfig.newBuilder()
              .setAutoscalingLimits(
                  AutoscalingConfig.AutoscalingLimits.newBuilder().setMinNodes(1).setMaxNodes(2))
              .setAutoscalingTargets(
                  AutoscalingConfig.AutoscalingTargets.newBuilder()
                      .setHighPriorityCpuUtilizationPercent(65)
                      .setStorageUtilizationPercent(95))
              .addAsymmetricAutoscalingOptions(
                  AutoscalingConfig.AsymmetricAutoscalingOption.newBuilder()
                  .setReplicaSelection(ReplicaSelection.newBuilder().setLocation("europe-west1")))
              .addAsymmetricAutoscalingOptions(
                  AutoscalingConfig.AsymmetricAutoscalingOption.newBuilder()
                  .setReplicaSelection(ReplicaSelection.newBuilder().setLocation("europe-west4")))
              .addAsymmetricAutoscalingOptions(
                  AutoscalingConfig.AsymmetricAutoscalingOption.newBuilder()
                  .setReplicaSelection(ReplicaSelection.newBuilder().setLocation("asia-east1")))
              .build();
      Instance instance =
          Instance.newBuilder()
              .setAutoscalingConfig(autoscalingConfig)
              .setDisplayName(displayName)
              .setConfig(
                  InstanceConfigName.of(projectId, configId).toString())
              .build();

      // Creates a new instance
      System.out.printf("Creating instance %s.%n", instanceId);
      try {
        // Wait for the createInstance operation to finish.
        Instance instanceResult = instanceAdminClient.createInstanceAsync(
            CreateInstanceRequest.newBuilder()
                .setParent(ProjectName.of(projectId).toString())
                .setInstanceId(instanceId)
                .setInstance(instance)
                .build()).get();
        System.out.printf("Asymmetric Autoscaling instance %s was successfully created%n",
            instanceResult.getName());
      } catch (ExecutionException e) {
        System.out.printf(
            "Error: Creating instance %s failed with error message %s%n",
            instance.getName(), e.getMessage());
      } catch (InterruptedException e) {
        System.out.println("Error: Waiting for createInstance operation to finish was interrupted");
      }
    }
  }
}

יצירת מכונה עם התאמה אסימטרית לקריאה בלבד באמצעות Java

import com.google.cloud.spanner.Spanner;
import com.google.cloud.spanner.SpannerOptions;
import com.google.cloud.spanner.admin.instance.v1.InstanceAdminClient;
import com.google.spanner.admin.instance.v1.AutoscalingConfig;
import com.google.spanner.admin.instance.v1.CreateInstanceRequest;
import com.google.spanner.admin.instance.v1.Instance;
import com.google.spanner.admin.instance.v1.InstanceConfigName;
import com.google.spanner.admin.instance.v1.ProjectName;
import com.google.spanner.admin.instance.v1.ReplicaSelection;
import java.util.concurrent.ExecutionException;

class CreateInstanceWithAsymmetricAutoscalingConfigExample {

  static void createInstance() {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "my-project";
    String instanceId = "my-instance";
    createInstance(projectId, instanceId);
  }

  static void createInstance(String projectId, String instanceId) {
    try (Spanner spanner =
        SpannerOptions.newBuilder()
            .setProjectId(projectId)
            .build()
            .getService();
        InstanceAdminClient instanceAdminClient = spanner.createInstanceAdminClient()) {
      // Set Instance configuration.
      String configId = "nam-eur-asia3";
      String displayName = "Descriptive name";

      // Create an autoscaling config.
      // When autoscaling_config is enabled, node_count and processing_units fields
      // need not be specified.
      // The read-only replicas listed in the asymmetric autoscaling options scale independently
      // from other replicas.
      AutoscalingConfig autoscalingConfig =
          AutoscalingConfig.newBuilder()
              .setAutoscalingLimits(
                  AutoscalingConfig.AutoscalingLimits.newBuilder().setMinNodes(1).setMaxNodes(2))
              .setAutoscalingTargets(
                  AutoscalingConfig.AutoscalingTargets.newBuilder()
                      .setHighPriorityCpuUtilizationPercent(65)
                      .setStorageUtilizationPercent(95))
              .addAsymmetricAutoscalingOptions(
                  AutoscalingConfig.AsymmetricAutoscalingOption.newBuilder()
                  .setReplicaSelection(ReplicaSelection.newBuilder().setLocation("europe-west1")))
              .addAsymmetricAutoscalingOptions(
                  AutoscalingConfig.AsymmetricAutoscalingOption.newBuilder()
                  .setReplicaSelection(ReplicaSelection.newBuilder().setLocation("europe-west4")))
              .addAsymmetricAutoscalingOptions(
                  AutoscalingConfig.AsymmetricAutoscalingOption.newBuilder()
                  .setReplicaSelection(ReplicaSelection.newBuilder().setLocation("asia-east1")))
              .build();
      Instance instance =
          Instance.newBuilder()
              .setAutoscalingConfig(autoscalingConfig)
              .setDisplayName(displayName)
              .setConfig(
                  InstanceConfigName.of(projectId, configId).toString())
              .build();

      // Creates a new instance
      System.out.printf("Creating instance %s.%n", instanceId);
      try {
        // Wait for the createInstance operation to finish.
        Instance instanceResult = instanceAdminClient.createInstanceAsync(
            CreateInstanceRequest.newBuilder()
                .setParent(ProjectName.of(projectId).toString())
                .setInstanceId(instanceId)
                .setInstance(instance)
                .build()).get();
        System.out.printf("Asymmetric Autoscaling instance %s was successfully created%n",
            instanceResult.getName());
      } catch (ExecutionException e) {
        System.out.printf(
            "Error: Creating instance %s failed with error message %s%n",
            instance.getName(), e.getMessage());
      } catch (InterruptedException e) {
        System.out.println("Error: Waiting for createInstance operation to finish was interrupted");
      }
    }
  }
}

יצירת מכונה בלי תזמון גיבוי כברירת מחדל

import com.google.cloud.spanner.Spanner;
import com.google.cloud.spanner.SpannerOptions;
import com.google.cloud.spanner.admin.instance.v1.InstanceAdminClient;
import com.google.spanner.admin.instance.v1.CreateInstanceRequest;
import com.google.spanner.admin.instance.v1.Instance;
import com.google.spanner.admin.instance.v1.InstanceConfigName;
import com.google.spanner.admin.instance.v1.ProjectName;
import java.util.concurrent.ExecutionException;

class CreateInstanceWithoutDefaultBackupSchedulesExample {

  static void createInstanceWithoutDefaultBackupSchedules() {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "my-project";
    String instanceId = "my-instance";
    createInstanceWithoutDefaultBackupSchedules(projectId, instanceId);
  }

  static void createInstanceWithoutDefaultBackupSchedules(String projectId, String instanceId) {
    // Set Instance configuration.
    int nodeCount = 2;
    String displayName = "Descriptive name";

    // Create an Instance object that will be used to create the instance.
    Instance instance =
        Instance.newBuilder()
            .setDisplayName(displayName)
            .setDefaultBackupScheduleType(Instance.DefaultBackupScheduleType.NONE)
            .setNodeCount(nodeCount)
            .setConfig(InstanceConfigName.of(projectId, "regional-us-east4").toString())
            .build();

    try (Spanner spanner =
            SpannerOptions.newBuilder().setProjectId(projectId).build().getService();
        InstanceAdminClient instanceAdminClient = spanner.createInstanceAdminClient()) {

      // Wait for the createInstance operation to finish.
      Instance createdInstance =
          instanceAdminClient
              .createInstanceAsync(
                  CreateInstanceRequest.newBuilder()
                      .setParent(ProjectName.of(projectId).toString())
                      .setInstanceId(instanceId)
                      .setInstance(instance)
                      .build())
              .get();
      System.out.printf("Instance %s was successfully created%n", createdInstance.getName());
    } catch (ExecutionException e) {
      System.out.printf(
          "Error: Creating instance %s failed with error message %s%n",
          instance.getName(), e.getMessage());
    } catch (InterruptedException e) {
      System.out.println("Error: Waiting for createInstance operation to finish was interrupted");
    }
  }
}

Node.js

במאמר ספריות הלקוח של Spanner מוסבר איך להתקין את ספריית הלקוח ולהשתמש בה ב-Spanner.

כדי לבצע אימות ב-Spanner, צריך להגדיר את Application Default Credentials. למידע נוסף, ראו הגדרת אימות לסביבת פיתוח מקומית.

// Imports the Google Cloud client library
const {Spanner, protos} = require('@google-cloud/spanner');

// Creates a client
const spanner = new Spanner({
  projectId: projectId,
});

const instanceAdminClient = await spanner.getInstanceAdminClient();
/**
 * TODO(developer): Uncomment the following lines before running the sample.
 **/
// const projectId = 'my-project-id';
// const instanceId = 'my-instance';

// Creates a new instance
try {
  console.log(
    `Creating instance ${instanceAdminClient.instancePath(
      projectId,
      instanceId,
    )}.`,
  );
  const [operation] = await instanceAdminClient.createInstance({
    instanceId: instanceId,
    parent: instanceAdminClient.projectPath(projectId),
    instance: {
      config: instanceAdminClient.instanceConfigPath(
        projectId,
        'regional-us-central1',
      ),
      nodeCount: 1,
      displayName: 'Display name for the instance.',
      labels: {
        cloud_spanner_samples: 'true',
        created: Math.round(Date.now() / 1000).toString(), // current time
      },
      edition:
        protos.google.spanner.admin.instance.v1.Instance.Edition.STANDARD, //optional
    },
  });

  console.log(`Waiting for operation on ${instanceId} to complete...`);
  await operation.promise();

  console.log(`Created instance ${instanceId}.`);
} catch (err) {
  console.error('ERROR:', err);
}

הערה: דוגמאות הקוד של הממשק הישן של ספריית הלקוח ל-Node.js נשמרות בארכיון ב-GitHub.

יצירת מכונה עם התאמה אוטומטית מנוהלת לעומס באמצעות Node.js

במאמר ספריות הלקוח של Spanner מוסבר איך להתקין את ספריית הלקוח ולהשתמש בה ב-Spanner.

כדי לבצע אימות ב-Spanner, צריך להגדיר את Application Default Credentials. למידע נוסף, ראו הגדרת אימות לסביבת פיתוח מקומית.

// Imports the Google Cloud client library
const {Spanner, protos} = require('@google-cloud/spanner');

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// const projectId = 'my-project-id';
// const instanceId = 'my-instance';

// Creates a client
const spanner = new Spanner({
  projectId: projectId,
});

// Get the instance admin client
const instanceAdminClient = spanner.getInstanceAdminClient();

const autoscalingConfig =
  protos.google.spanner.admin.instance.v1.AutoscalingConfig.create({
    // Only one of minNodes/maxNodes or minProcessingUnits/maxProcessingUnits can be set.
    autoscalingLimits:
      protos.google.spanner.admin.instance.v1.AutoscalingConfig.AutoscalingLimits.create(
        {
          minNodes: 1,
          maxNodes: 2,
        },
      ),
    // highPriorityCpuUtilizationPercent and storageUtilizationPercent are both
    // percentages and must lie between 0 and 100.
    autoscalingTargets:
      protos.google.spanner.admin.instance.v1.AutoscalingConfig.AutoscalingTargets.create(
        {
          highPriorityCpuUtilizationPercent: 65,
          storageUtilizationPercent: 95,
        },
      ),
  });

// Creates a new instance with autoscaling configuration
// When autoscalingConfig is enabled, nodeCount and processingUnits fields
// need not be specified.
try {
  console.log(
    `Creating instance ${instanceAdminClient.instancePath(
      projectId,
      instanceId,
    )}.`,
  );
  const [operation] = await instanceAdminClient.createInstance({
    instanceId: instanceId,
    parent: instanceAdminClient.projectPath(projectId),
    instance: {
      config: instanceAdminClient.instanceConfigPath(
        projectId,
        'regional-us-central1',
      ),
      displayName: 'Display name for the instance.',
      autoscalingConfig: autoscalingConfig,
      labels: {
        cloud_spanner_samples: 'true',
        created: Math.round(Date.now() / 1000).toString(), // current time
      },
      // Managed autoscaler is available only for ENTERPRISE edition
      edition:
        protos.google.spanner.admin.instance.v1.Instance.Edition.ENTERPRISE,
    },
  });

  console.log(`Waiting for operation on ${instanceId} to complete...`);
  await operation.promise();
  console.log(`Created instance ${instanceId}.`);

  // get instance metadata
  const [metadata] = await instanceAdminClient.getInstance({
    name: instanceAdminClient.instancePath(projectId, instanceId),
  });
  console.log(
    `Autoscaling configurations of ${instanceId} are:  ` +
      '\n' +
      `Min nodes: ${metadata.autoscalingConfig.autoscalingLimits.minNodes} ` +
      'nodes.' +
      '\n' +
      `Max nodes: ${metadata.autoscalingConfig.autoscalingLimits.maxNodes}` +
      ' nodes.' +
      '\n' +
      `High priority cpu utilization percent: ${metadata.autoscalingConfig.autoscalingTargets.highPriorityCpuUtilizationPercent}.` +
      '\n' +
      `Storage utilization percent: ${metadata.autoscalingConfig.autoscalingTargets.storageUtilizationPercent}.`,
  );
} catch (err) {
  console.error('ERROR:', err);
}

יצירת מכונה בלי תזמון גיבוי כברירת מחדל

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 **/
// const projectId = 'my-project-id';
// const instanceId = 'my-instance';

// Imports the Google Cloud client library
const {Spanner, protos} = require('@google-cloud/spanner');

// Creates a client
const spanner = new Spanner({
  projectId: projectId,
});

const instanceAdminClient = await spanner.getInstanceAdminClient();
// Creates a new instance
try {
  const [operation] = await instanceAdminClient.createInstance({
    instanceId: instanceId,
    parent: instanceAdminClient.projectPath(projectId),
    instance: {
      config: instanceAdminClient.instanceConfigPath(
        projectId,
        'regional-me-central2',
      ),
      nodeCount: 1,
      displayName: 'Display name for the instance.',
      labels: {
        cloud_spanner_samples: 'true',
        created: Math.round(Date.now() / 1000).toString(), // current time
      },
      defaultBackupScheduleType:
        protos.google.spanner.admin.instance.v1.Instance
          .DefaultBackupScheduleType.NONE,
    },
  });
  await operation.promise();

  console.log(
    `Created instance ${instanceId} without default backup schedules.`,
  );
} catch (err) {
  console.error('ERROR:', err);
}

PHP

במאמר ספריות הלקוח של Spanner מוסבר איך להתקין את ספריית הלקוח ולהשתמש בה ב-Spanner.

כדי לבצע אימות ב-Spanner, צריך להגדיר את Application Default Credentials. למידע נוסף, ראו הגדרת אימות לסביבת פיתוח מקומית.

use Google\Cloud\Spanner\Admin\Instance\V1\Client\InstanceAdminClient;
use Google\Cloud\Spanner\Admin\Instance\V1\CreateInstanceRequest;
use Google\Cloud\Spanner\Admin\Instance\V1\Instance;

/**
 * Creates an instance.
 * Example:
 * ```
 * create_instance($projectId, $instanceId);
 * ```
 *
 * @param string $projectId  The Spanner project ID.
 * @param string $instanceId The Spanner instance ID.
 */
function create_instance(string $projectId, string $instanceId): void
{
    $instanceAdminClient = new InstanceAdminClient();
    $parent = InstanceAdminClient::projectName($projectId);
    $instanceName = InstanceAdminClient::instanceName($projectId, $instanceId);
    $configName = $instanceAdminClient->instanceConfigName($projectId, 'regional-us-central1');
    $instance = (new Instance())
        ->setName($instanceName)
        ->setConfig($configName)
        ->setDisplayName('dispName')
        ->setNodeCount(1);

    $operation = $instanceAdminClient->createInstance(
        (new CreateInstanceRequest())
        ->setParent($parent)
        ->setInstanceId($instanceId)
        ->setInstance($instance)
    );

    print('Waiting for operation to complete...' . PHP_EOL);
    $operation->pollUntilComplete();

    printf('Created instance %s' . PHP_EOL, $instanceId);
}

הערה: דוגמאות הקוד של הממשק הישן של ספריית הלקוח ל-PHP נשמרות בארכיון ב-GitHub.

Python

במאמר ספריות הלקוח של Spanner מוסבר איך להתקין את ספריית הלקוח ולהשתמש בה ב-Spanner.

כדי לבצע אימות ב-Spanner, צריך להגדיר את Application Default Credentials. למידע נוסף, ראו הגדרת אימות לסביבת פיתוח מקומית.

def create_instance(instance_id):
    """Creates an instance."""
    from google.cloud.spanner_admin_instance_v1.types import spanner_instance_admin

    spanner_client = spanner.Client()

    config_name = "{}/instanceConfigs/regional-us-central1".format(
        spanner_client.project_name
    )

    operation = spanner_client.instance_admin_api.create_instance(
        parent=spanner_client.project_name,
        instance_id=instance_id,
        instance=spanner_instance_admin.Instance(
            config=config_name,
            display_name="This is a display name.",
            node_count=1,
            labels={
                "cloud_spanner_samples": "true",
                "sample_name": "snippets-create_instance-explicit",
                "created": str(int(time.time())),
            },
            edition=spanner_instance_admin.Instance.Edition.STANDARD,  # Optional
        ),
    )

    print("Waiting for operation to complete...")
    operation.result(OPERATION_TIMEOUT_SECONDS)

    print("Created instance {}".format(instance_id))

הערה: דוגמאות הקוד של הממשק הישן של ספריית הלקוח ל-Python נשמרות בארכיון ב-GitHub.

יצירת מכונה עם התאמה אוטומטית מנוהלת לעומס באמצעות Python

במאמר ספריות הלקוח של Spanner מוסבר איך להתקין את ספריית הלקוח ולהשתמש בה ב-Spanner.

כדי לבצע אימות ב-Spanner, צריך להגדיר את Application Default Credentials. למידע נוסף, ראו הגדרת אימות לסביבת פיתוח מקומית.

def create_instance_with_autoscaling_config(instance_id):
    """Creates a Cloud Spanner instance with an autoscaling configuration."""
    from google.cloud.spanner_admin_instance_v1.types import spanner_instance_admin

    spanner_client = spanner.Client()

    config_name = "{}/instanceConfigs/regional-us-central1".format(
        spanner_client.project_name
    )

    autoscaling_config = spanner_instance_admin.AutoscalingConfig(
        # Only one of minNodes/maxNodes or minProcessingUnits/maxProcessingUnits can be set.
        autoscaling_limits=spanner_instance_admin.AutoscalingConfig.AutoscalingLimits(
            min_nodes=1,
            max_nodes=2,
        ),
        # highPriorityCpuUtilizationPercent and storageUtilizationPercent are both
        # percentages and must lie between 0 and 100.
        autoscaling_targets=spanner_instance_admin.AutoscalingConfig.AutoscalingTargets(
            high_priority_cpu_utilization_percent=65,
            storage_utilization_percent=95,
        ),
    )

    #  Creates a new instance with autoscaling configuration
    #  When autoscalingConfig is enabled, nodeCount and processingUnits fields
    #  need not be specified.
    request = spanner_instance_admin.CreateInstanceRequest(
        parent=spanner_client.project_name,
        instance_id=instance_id,
        instance=spanner_instance_admin.Instance(
            config=config_name,
            display_name="This is a display name.",
            autoscaling_config=autoscaling_config,
            labels={
                "cloud_spanner_samples": "true",
                "sample_name": "snippets-create_instance_with_autoscaling_config",
                "created": str(int(time.time())),
            },
            edition=spanner_instance_admin.Instance.Edition.ENTERPRISE,  # Optional
        ),
    )

    operation = spanner_client.instance_admin_api.create_instance(request=request)

    print("Waiting for operation to complete...")
    instance = operation.result(OPERATION_TIMEOUT_SECONDS)

    print(
        "Created instance {} with {} autoscaling config".format(
            instance_id, instance.autoscaling_config
        )
    )

יצירת מכונה בלי תזמון גיבוי כברירת מחדל

def create_instance_without_default_backup_schedules(instance_id):
    spanner_client = spanner.Client()
    config_name = "{}/instanceConfigs/regional-me-central2".format(
        spanner_client.project_name
    )

    operation = spanner_client.instance_admin_api.create_instance(
        parent=spanner_client.project_name,
        instance_id=instance_id,
        instance=spanner_instance_admin.Instance(
            config=config_name,
            display_name="This is a display name.",
            node_count=1,
            default_backup_schedule_type=spanner_instance_admin.Instance.DefaultBackupScheduleType.NONE,  # Optional
        ),
    )

    print("Waiting for operation to complete...")
    operation.result(OPERATION_TIMEOUT_SECONDS)

    print("Created instance {} without default backup schedules".format(instance_id))

Ruby

במאמר ספריות הלקוח של Spanner מוסבר איך להתקין את ספריית הלקוח ולהשתמש בה ב-Spanner.

כדי לבצע אימות ב-Spanner, צריך להגדיר את Application Default Credentials. למידע נוסף, ראו הגדרת אימות לסביבת פיתוח מקומית.

# project_id  = "Your Google Cloud project ID"
# instance_id = "Your Spanner instance ID"
# instance_config_id = "Your Spanner InstanceConfig ID"

require "google/cloud/spanner"
require "google/cloud/spanner/admin/instance"

instance_admin_client = Google::Cloud::Spanner::Admin::Instance.instance_admin

project_path = instance_admin_client.project_path project: project_id
instance_path = instance_admin_client.instance_path project: project_id, instance: instance_id
instance_config_path = instance_admin_client.instance_config_path project: project_id, instance_config: instance_config_id

job = instance_admin_client.create_instance parent: project_path,
                                            instance_id: instance_id,
                                            instance: { name: instance_path,
                                                        config: instance_config_path,
                                                        display_name: instance_id,
                                                        node_count: 2,
                                                        labels: { cloud_spanner_samples: "true" } }

puts "Waiting for create instance operation to complete"

job.wait_until_done!

if job.error?
  puts job.error
else
  puts "Created instance #{instance_id}"
end

הצגת רשימת המכונות

אתם יכולים להציג רשימה של מכונות Spanner.

המסוף

נכנסים לדף Spanner Instances במסוף Google Cloud .

כניסה לדף Instances

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

gcloud

משתמשים בפקודה gcloud spanner instances list:

gcloud spanner instances list

ה-CLI של gcloud מדפיס רשימה של המכונות של Spanner, יחד עם המזהה, השם המוצג, ההגדרות ויכולת המחשוב של כל מכונה.

עריכת מופע

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

שדרוג המהדורה

אתם יכולים לשדרג את המכונות של מהדורת Standard למהדורה ברמה גבוהה יותר. אפשר לשדרג מכונות של מהדורת Standard למהדורת Enterprise או למהדורת Enterprise Plus, כל עוד לא נמנע מהן לעשות זאת בגלל אילוץ של מדיניות הארגון. אפשר לשדרג מכונות במהדורת Enterprise למהדורת Enterprise Plus. שדרוג המהדורה נמשך כ-10 דקות, ללא זמן השבתה.

המסוף

1. נכנסים לדף Spanner Instances במסוף Google Cloud .

   כניסה לדף Instances

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

3. לוחצים על שדרוג לצד סוג המהדורה.

4. בדף Edition instance, בקטע Update edition, בוחרים את המהדורה החדשה ברמה גבוהה יותר למכונה.

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

gcloud

משתמשים בפקודה gcloud spanner instances update כדי לשדרג את המהדורה של המכונה:

gcloud spanner instances update INSTANCE_ID --edition=EDITION \
[--async]

מחליפים את מה שכתוב בשדות הבאים:

• ‫INSTANCE_ID: המזהה הקבוע של המכונה.
• ‫EDITION: מציינים את המהדורה החדשה ברמה גבוהה יותר של המכונה. מידע נוסף זמין בסקירה הכללית על מהדורות Spanner.

דגלים אופציונליים:

• ‫--async: משתמשים בדגל הזה אם רוצים שהבקשה תחזור מיד, בלי לחכות שהפעולה תסתיים. כדי לבדוק את סטטוס הבקשה, אפשר להריץ את הפקודה gcloud spanner operations describe.

המשך

import (
	"context"
	"fmt"
	"io"

	instance "cloud.google.com/go/spanner/admin/instance/apiv1"
	"cloud.google.com/go/spanner/admin/instance/apiv1/instancepb"
	"google.golang.org/genproto/protobuf/field_mask"
)

func updateInstance(w io.Writer, projectID, instanceID string) error {
	// projectID := "my-project-id"
	// instanceID := "my-instance"
	ctx := context.Background()
	instanceAdmin, err := instance.NewInstanceAdminClient(ctx)
	if err != nil {
		return err
	}
	defer instanceAdmin.Close()

	req := &instancepb.UpdateInstanceRequest{
		Instance: &instancepb.Instance{
			Name: fmt.Sprintf("projects/%s/instances/%s", projectID, instanceID),
			// The edition selected for this instance.
			// Different editions provide different capabilities at different price points.
			// For more information, see https://cloud.google.com/spanner/docs/editions-overview.
			Edition: instancepb.Instance_ENTERPRISE,
		},
		FieldMask: &field_mask.FieldMask{
			Paths: []string{"edition"},
		},
	}
	op, err := instanceAdmin.UpdateInstance(ctx, req)
	if err != nil {
		return fmt.Errorf("could not update instance %s: %w", fmt.Sprintf("projects/%s/instances/%s", projectID, instanceID), err)
	}
	// Wait for the instance update to finish.
	_, err = op.Wait(ctx)
	if err != nil {
		return fmt.Errorf("waiting for instance update to finish failed: %w", err)
	}

	fmt.Fprintf(w, "Updated instance [%s]\n", instanceID)
	return nil
}

Java

import com.google.cloud.spanner.Spanner;
import com.google.cloud.spanner.SpannerOptions;
import com.google.cloud.spanner.admin.instance.v1.InstanceAdminClient;
import com.google.common.collect.Lists;
import com.google.protobuf.FieldMask;
import com.google.spanner.admin.instance.v1.Instance;
import com.google.spanner.admin.instance.v1.InstanceConfigName;
import com.google.spanner.admin.instance.v1.InstanceName;
import com.google.spanner.admin.instance.v1.UpdateInstanceRequest;
import java.util.concurrent.ExecutionException;

public class UpdateInstanceExample {

  static void updateInstance() {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "my-project";
    String instanceId = "my-instance";
    updateInstance(projectId, instanceId);
  }

  static void updateInstance(String projectId, String instanceId) {
    // Set Instance configuration.
    int nodeCount = 2;
    String displayName = "Updated name";

    // Update an Instance object that will be used to update the instance.
    Instance instance =
        Instance.newBuilder()
            .setName(InstanceName.of(projectId, instanceId).toString())
            .setDisplayName(displayName)
            .setNodeCount(nodeCount)
            .setEdition(Instance.Edition.ENTERPRISE)
            .setConfig(InstanceConfigName.of(projectId, "regional-us-east4").toString())
            .build();

    try (Spanner spanner =
            SpannerOptions.newBuilder().setProjectId(projectId).build().getService();
        InstanceAdminClient instanceAdminClient = spanner.createInstanceAdminClient()) {

      // Wait for the updatedInstance operation to finish.
      Instance updatedInstance =
          instanceAdminClient
              .updateInstanceAsync(
                  UpdateInstanceRequest.newBuilder()
                      .setFieldMask(
                          FieldMask.newBuilder().addAllPaths(Lists.newArrayList("edition")))
                      .setInstance(instance)
                      .build())
              .get();
      System.out.printf("Instance %s was successfully updated%n", updatedInstance.getName());
    } catch (ExecutionException e) {
      System.out.printf(
          "Error: Updating instance %s failed with error message %s%n",
          instance.getName(), e.getMessage());
    } catch (InterruptedException e) {
      System.out.println("Error: Waiting for updateInstance operation to finish was interrupted");
    }
  }
}

Node.js

במאמר ספריות הלקוח של Spanner מוסבר איך להתקין את ספריית הלקוח ולהשתמש בה ב-Spanner.

כדי לבצע אימות ב-Spanner, צריך להגדיר את Application Default Credentials. למידע נוסף, ראו הגדרת אימות לסביבת פיתוח מקומית.

// Imports the Google Cloud client library
const {Spanner, protos} = require('@google-cloud/spanner');

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// const projectId = 'my-project-id';
// const instanceId = 'my-instance';

// Creates a client
const spanner = new Spanner({
  projectId: projectId,
});

const instanceAdminClient = spanner.getInstanceAdminClient();

// Updates an instance
try {
  console.log(
    `Updating instance ${instanceAdminClient.instancePath(
      projectId,
      instanceId,
    )}.`,
  );
  const [operation] = await instanceAdminClient.updateInstance({
    instance: {
      name: instanceAdminClient.instancePath(projectId, instanceId),
      labels: {
        updated: 'true',
        created: Math.round(Date.now() / 1000).toString(), // current time
      },
      edition:
        protos.google.spanner.admin.instance.v1.Instance.Edition.ENTERPRISE, //optional
    },
    // Field mask specifying fields that should get updated in an Instance
    fieldMask: (protos.google.protobuf.FieldMask = {
      paths: ['labels', 'edition'],
    }),
  });

  console.log(`Waiting for operation on ${instanceId} to complete...`);
  await operation.promise();
  console.log(`Updated instance ${instanceId}.`);
  const [metadata] = await instanceAdminClient.getInstance({
    name: instanceAdminClient.instancePath(projectId, instanceId),
  });
  console.log(
    `Instance ${instanceId} has been updated with the ${metadata.edition} ` +
      'edition.',
  );
} catch (err) {
  console.error('ERROR:', err);
}

Python

במאמר ספריות הלקוח של Spanner מוסבר איך להתקין את ספריית הלקוח ולהשתמש בה ב-Spanner.

כדי לבצע אימות ב-Spanner, צריך להגדיר את Application Default Credentials. למידע נוסף, ראו הגדרת אימות לסביבת פיתוח מקומית.

def update_instance(instance_id):
    """Updates an instance."""
    from google.cloud.spanner_admin_instance_v1.types import spanner_instance_admin

    spanner_client = spanner.Client()

    name = "{}/instances/{}".format(spanner_client.project_name, instance_id)

    operation = spanner_client.instance_admin_api.update_instance(
        instance=spanner_instance_admin.Instance(
            name=name,
            labels={
                "sample_name": "snippets-update_instance-explicit",
            },
            edition=spanner_instance_admin.Instance.Edition.ENTERPRISE,  # Optional
        ),
        field_mask=field_mask_pb2.FieldMask(paths=["labels", "edition"]),
    )

    print("Waiting for operation to complete...")
    operation.result(900)

    print("Updated instance {}".format(instance_id))

מעבר למהדורה קודמת

אתם יכולים לשדרג לאחור את מכונות Spanner למהדורה ברמה נמוכה יותר. כדי לשדרג לאחור, צריך להפסיק להשתמש בתכונות של המהדורה ברמה הגבוהה יותר. אפשר לשדרג לאחור מכונות של מהדורת Enterprise למהדורת Standard. אפשר לשדרג לאחור מכונות במהדורת Enterprise Plus למהדורת Enterprise או למהדורת Standard. המעבר לגרסה קודמת נמשך כ-10 דקות, בלי זמן השבתה.

כדי לעקוב אחרי השימוש בתכונות של מהדורת Enterprise ומהדורת Enterprise Plus במכונה שלכם, אתם יכולים להשתמש במדד המעקב Feature usage (instance/edition/feature_usage). מידע נוסף זמין במאמר מעקב אחרי השימוש במהדורה.

המסוף

1. נכנסים לדף Spanner Instances במסוף Google Cloud .

   כניסה לדף Instances

2. לוחצים על השם של המכונה שרוצים לשדרג לאחור.

3. בדף Instance overview, לוחצים על Edit instance.

4. בדף Edit instance, בקטע Choose a Spanner edition, בוחרים את המהדורה ברמה הנמוכה יותר.

5. לוחצים על Update instance.

gcloud

משתמשים בפקודה gcloud spanner instances update כדי לשדרג לאחור את המהדורה של המכונה:

gcloud spanner instances update INSTANCE_ID --edition=EDITION

מחליפים את מה שכתוב בשדות הבאים:

• ‫INSTANCE_ID: המזהה הקבוע של המכונה.
• ‫EDITION: מציינים את המהדורה החדשה ברמה נמוכה יותר של המכונה. מידע נוסף זמין בסקירה הכללית על מהדורות Spanner.

שינוי השם המוצג

המסוף

1. נכנסים לדף Spanner Instances במסוף Google Cloud .

   כניסה לדף Instances

2. לוחצים על השם של המכונה שרוצים לשנות.

3. לוחצים על Edit instance.

4. מזינים שם חדש למכונה. השם חייב להיות ייחודי בפרויקט ב-Google Cloud .

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

gcloud

משתמשים בפקודה gcloud spanner instances update:

gcloud spanner instances update INSTANCE_ID --description=INSTANCE_NAME

מחליפים את מה שכתוב בשדות הבאים:

• ‫INSTANCE_ID: המזהה הקבוע של המכונה.
• ‫INSTANCE_NAME: השם שיוצג למכונה במסוףGoogle Cloud . שם המכונה חייב להיות ייחודי בפרויקט ב-Google Cloud .

שינוי קיבולת המחשוב

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

אתם יכולים להקטין את קיבולת המחשוב של מכונה ב-Spanner, חוץ מהמקרים הבאים:

• אי אפשר לאחסן יותר מ-10TiB של נתונים לכל צומת (1,000 יחידות עיבוד).

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

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

כשמסירים קיבולת מחשוב, צריך לעקוב אחרי ניצול המעבד (CPU) וזמן האחזור של הבקשות ב-Cloud Monitoring כדי לוודא שניצול המעבד נשאר מתחת ל-65% במכונות אזוריות ומתחת ל-45% בכל אזור במכונות בכמה אזורים. יכול להיות שתהיה עלייה זמנית בזמן האחזור של הבקשות בזמן הסרת קיבולת המחשוב.

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

המסוף

1. נכנסים לדף Spanner Instances במסוף Google Cloud .

   כניסה לדף Instances

2. לוחצים על שם המכונה שרוצים לשנות.

3. לוחצים על Edit Instance.

4. כדי לשנות את קיבולת המחשוב, בוחרים את יחידות המידה (יחידות עיבוד או צמתים) ומזינים כמות. כשמשתמשים ביחידות עיבוד, צריך להזין כמויות עד 1,000 בכפולות של 100 (100, 200, 300 וכן הלאה) וכמויות גדולות יותר בכפולות של 1,000 (1,000, 2,000, 3,000 וכן הלאה). כל צומת שווה ל-1,000 יחידות עיבוד.

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

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

gcloud

משתמשים בפקודה gcloud spanner instances update. כשמשתמשים בפקודה הזו, מציינים את קיבולת המחשוב כמספר הצמתים או יחידות העיבוד.

gcloud spanner instances update INSTANCE_ID --nodes=NODE_COUNT
[--async]

או

gcloud spanner instances update INSTANCE_ID
--processing-units=PROCESSING_UNIT_COUNT [--async]

מחליפים את מה שכתוב בשדות הבאים:

• ‫INSTANCE_ID: המזהה הקבוע של המכונה.
• ‫NODE_COUNT: קיבולת המחשוב של המכונה, מבוטאת כמספר צמתים. כל צומת שווה ל-1,000 יחידות עיבוד.
• ‫PROCESSING_UNIT_COUNT: קיבולת המחשוב של המכונה, מבוטאת כמספר יחידות עיבוד. כמויות של עד 1,000 צריך להזין בכפולות של 100 (100, 200, 300 וכן הלאה), וכמויות גדולות יותר צריך להזין בכפולות של 1,000 (1,000, 2,000, 3,000 וכן הלאה).

דגלים אופציונליים:

• ‫--async: משתמשים בדגל הזה אם רוצים שהבקשה תחזור מיד, בלי לחכות שהפעולה תסתיים. כדי לבדוק את סטטוס הבקשה, אפשר להריץ את הפקודה gcloud spanner operations describe.

הפעלה או שינוי של מידרוג אוטומטי מנוהל במכונה

אפשר להפעיל או לשנות את ההתאמה האוטומטית לעומס במכונה של Spanner באמצעות מסוף Google Cloud , ה-CLI של gcloud או ספריות הלקוח של Spanner. כשמוסיפים או משנים את התכונה 'התאמה אוטומטית לעומס' במכונה קיימת, חלות המגבלות הבאות:

• התאמה אוטומטית מנוהלת לעומס זמינה רק במהדורת Enterprise או במהדורת Enterprise Plus.
• אי אפשר להפעיל את המידרוג האוטומטי המנוהל במכונה שאתם מעבירים.

• אי אפשר להעביר מכונה כשהמידרוג האוטומטי המנוהל פועל.

המסוף

1. נכנסים לדף Spanner Instances במסוף Google Cloud .

   כניסה לדף Instances

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

3. לוחצים על Edit instance.

4. בקטע Configure compute capacity, לוחצים על Autoscaling.

5. בשדה Minimum, בוחרים את הגבול המינימלי לצמצום אנכית (scale down). מידע נוסף זמין במאמר קביעת המגבלה המינימלית.

6. בשדה Maximum, בוחרים את המגבלה המקסימלית לשימוש בהגדלת קנה המידה. איך קובעים את המגבלה המקסימלית

7. בשדה High priority CPU utilization target, בוחרים את אחוז ה-CPU שיוקצה למשימות בעדיפות גבוהה. מידע נוסף זמין במאמר הגדרת יעד לניצול המעבד (CPU).

8. בשדה Total CPU utilization target, בוחרים את אחוז היעד של המעבד (CPU) לשימוש בכל המשימות בעדיפות נמוכה, בינונית וגבוהה. אחוז המעבד יכול להיות בין 10% ל-90%. מידע נוסף זמין במאמר הגדרת היעד הכולל של ניצול ה-CPU.

9. בשדה Storage utilization target, בוחרים את אחוז האחסון שרוצים להשתמש בו. מידע נוסף זמין במאמר הגדרת יעד לניצול נפח האחסון.

10. אופציונלי: אם בוחרים באפשרות Autoscaling כמצב ההתאמה לעומס, אפשר ללחוץ על התפריט הנפתח Show asymmetric autoscaling options כדי להתאים אוטומטית לעומס את הרפליקות לקריאה בלבד, בלי קשר לרפליקות אחרות.

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

    2. מגדירים את האפשרויות הבאות של ההתאמה לעומס (autoscaler):

       • הערך Minimum מציין את הגבול המינימלי לצמצום אנכי בהתאם לעומס, בהתאם ליחידת המידה שבחרתם ל-Compute capacity. מידע נוסף זמין במאמר קביעת המגבלה המינימלית.
       • הערך של Maximum מציין את הגבול המקסימלי להגדלת קנה המידה, בהתאם ליחידת המידה שבחרתם ל-Compute capacity. מידע נוסף זמין במאמר קביעת המגבלה המקסימלית.
       • יעד ניצול המעבד (CPU) בעדיפות גבוהה מציין את אחוז היעד של המעבד (CPU) לשימוש במשימות בעדיפות גבוהה. למידע נוסף, קראו את המאמר קביעת היעד לניצול המעבד (CPU) בעדיפות גבוהה.
       • Total CPU utilization target מציין את אחוז היעד של ה-CPU שבו יש להשתמש לכל המשימות בעדיפות נמוכה, בינונית וגבוהה. אחוז המעבד יכול להיות בין 10% ל-90%. מידע נוסף זמין במאמר הגדרת היעד הכולל של ניצול ה-CPU.

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

gcloud

משתמשים בפקודה gcloud spanner instances update כדי להוסיף את המידרוג האוטומטי המנוהל למכונה. מידע נוסף ומגבלות מפורטים במאמר דגלים ומגבלות של Google Cloud CLI.

ניתן להוסיף את המידרוג האוטומטי המנוהל באמצעות הפקודה הבאה:

  gcloud spanner instances update INSTANCE_ID \
    --autoscaling-min-processing-units=MINIMUM_PROCESSING_UNITS \
    --autoscaling-max-processing-units=MAXIMUM_PROCESSING_UNITS \
    --autoscaling-high-priority-cpu-target=HIGH_PRIORITY_CPU_PERCENTAGE \
    --autoscaling-total-cpu-target=TOTAL_CPU_PERCENTAGE \
    --autoscaling-storage-target=STORAGE_PERCENTAGE \
    [--disable-downscaling | --no-disable-downscaling] \
    [--asymmetric-autoscaling-option \
       location=ASYMMETRIC_AUTOSCALING_LOCATION,\
       min_nodes=ASYMMETRIC_AUTOSCALING_MIN,\
       max_nodes=ASYMMETRIC_AUTOSCALING_MAX,\
       high_priority_cpu_target=ASYMMETRIC_HIGH_PRIORITY_CPU_TARGET,\
       total_cpu_target=ASYMMETRIC_TOTAL_CPU_TARGET,\
       disable_total_cpu_autoscaling=TRUE|FALSE
       | disable_high_priority_cpu_autoscaling=TRUE|FALSE]

או

  gcloud spanner instances update INSTANCE_ID \
    --autoscaling-min-processing-units=MINIMUM_NODES \
    --autoscaling-max-processing-units=MAXIMUM_NODES \
    --autoscaling-high-priority-cpu-target=HIGH_PRIORITY_CPU_PERCENTAGE \
    --autoscaling-total-cpu-target=TOTAL_CPU_PERCENTAGE \
    --autoscaling-storage-target=STORAGE_PERCENTAGE \
    [--disable-downscaling | --no-disable-downscaling] \
    [--asymmetric-autoscaling-option \
       location=ASYMMETRIC_AUTOSCALING_LOCATION,\
       min_nodes=ASYMMETRIC_AUTOSCALING_MIN,\
       max_nodes=ASYMMETRIC_AUTOSCALING_MAX,\
       high_priority_cpu_target=ASYMMETRIC_HIGH_PRIORITY_CPU_TARGET,\
       total_cpu_target=ASYMMETRIC_TOTAL_CPU_TARGET,\
       disable_total_cpu_autoscaling=TRUE|FALSE
       | disable_high_priority_cpu_autoscaling=TRUE|FALSE]

מחליפים את מה שכתוב בשדות הבאים:

• ‫INSTANCE_ID: המזהה הקבוע של המכונה.
• ‫MINIMUM_PROCESSING_UNITS, MINIMUM_NODES: המספר המינימלי של יחידות עיבוד או צמתים שבהם צריך להשתמש כשמצמצמים אנכית בהתאם לעומס (scale down). מידע נוסף מופיע בקטע קביעת המגבלה המינימלית.
• ‫MAXIMUM_PROCESSING_UNITS, MAXIMUM_NODES: המספר המקסימלי של יחידות עיבוד או צמתים שבהם אפשר להשתמש כשמגדילים את קנה המידה. איך קובעים את המגבלה המקסימלית
• ‫HIGH_PRIORITY_CPU_PERCENTAGE: אחוז היעד של שימוש במעבד (CPU) בעדיפות גבוהה, על סמך עדיפות המשימה. אחוז המעבד יכול להיות בין 10% ל-90%. אם אתם מבצעים אופטימיזציה לעלות, השתמשו באחוז גבוה יותר. למידע נוסף, קראו את המאמר קביעת היעד לניצול המעבד (CPU) בעדיפות גבוהה.
• ‫TOTAL_CPU_PERCENTAGE: אחוז היעד של סך כל המעבד (CPU) בעדיפות גבוהה שבו צריך להשתמש. יעד המעבד (CPU) הכולל צריך להיות גדול מיעד המעבד (CPU) בעדיפות גבוהה. אחוז המעבד יכול להיות בין 10% ל-90%. אם אתם מבצעים אופטימיזציה לעלות, השתמשו באחוז גבוה יותר. למידע נוסף, קראו את המאמר קביעת היעד הכולל של ניצול ה-CPU.
• ‫STORAGE_PERCENTAGE: אחוז היעד של נפח האחסון לשימוש, מ-10% עד 99%. מידע נוסף זמין במאמר הגדרת יעד לניצול נפח האחסון.

דגלים אופציונליים:

• ‫--disable-downscaling: משתמשים בדגל הבוליאני הזה כדי להשבית את הקטנת קנה המידה. כשהערך מוגדר כ-TRUE, המידרוג האוטומטי לא יכול להקטין את מספר הצמתים או יחידות העיבוד. הגדלת המכסות ממשיכה לפעול כרגיל כדי לעמוד בביקוש הגובר. כדי להפעיל את הקטנת קנה המידה אחרי שהשבתתם אותה, משתמשים בדגל --no-disable-downscaling.

• ‫--asymmetric-autoscaling-option: משתמשים בדגל הזה כדי להפעיל התאמה אסימטרית לעומס (autoscaling).

  מחליפים את הפרמטרים הבאים:

  • ‫ASYMMETRIC_AUTOSCALING_LOCATION: אם משתמשים בדגל של התאמה אסימטרית של קנה מידה, צריך להשתמש בפרמטר הזה. המיקום של האזור לקריאה בלבד שרוצים לשנות את הגודל שלו באופן אסימטרי.
  • ‫ASYMMETRIC_AUTOSCALING_MIN: פרמטר אופציונלי. מספר הצמתים המינימלי כשמצמצמים את קנה המידה. אם לא מציינים את הערך הזה, הוא עובר בירושה מהגדרת המכונה הבסיסית.
  • ‫ASYMMETRIC_AUTOSCALING_MAX: פרמטר אופציונלי. מספר הצמתים המקסימלי בהגדלת קנה המידה. אם לא מציינים את הערך הזה, הוא עובר בירושה מהגדרת המכונה הבסיסית.
  • ‫ASYMMETRIC_HIGH_PRIORITY_CPU_TARGET: פרמטר אופציונלי. אחוז היעד של המעבד (CPU) לשימוש, על סמך עדיפות המשימה. אם לא מציינים ערך, הוא עובר בירושה מהגדרת המכונה הבסיסית. אם אתם מבצעים אופטימיזציה לעלות, השתמשו באחוז גבוה יותר. לרפליקות יכול להיות אחוז יעד שונה מזה של המכונה הבסיסית ומרפליקות אחרות, אבל בתרחישים של יתירות כשל, מומלץ להשתמש ביעדים עקביים ברפליקות השונות. מידע נוסף זמין במאמר בעיות שקשורות ליתירות כשל.
  • ‫ASYMMETRIC_TOTAL_CPU_TARGET: פרמטר אופציונלי. מגדירים את היעד מ-10% עד 90% ל-total CPU. אם לא מציינים ערך, הוא עובר בירושה מהגדרת המכונה הבסיסית. אם אתם מבצעים אופטימיזציה לעלות, השתמשו באחוז גבוה יותר. לרפליקות יכול להיות אחוז יעד שונה מזה של המכונה הבסיסית ומרפליקות אחרות, אבל בתרחישים של יתירות כשל, מומלץ להשתמש ביעדים עקביים ברפליקות השונות. מידע נוסף זמין במאמר התאמה אסימטרית לקריאה בלבד של קנה המידה.
  • ‫disable_total_cpu_autoscaling: מגדירים את הפרמטר הזה לערך TRUE אם לא רוצים שהמנגנון להתאמה אוטומטית של קנה המידה יתאים אוטומטית את קנה המידה של סך כל ה-CPU ברפליקות. אם רוצים שהמכונה תירש את היעד total_cpu_autoscaling ממכונת הבסיס, לא צריך לציין את הפרמטר הזה. אי אפשר להשבית גם את סך כל המעבד (CPU) וגם את המעבד (CPU) בעדיפות גבוהה באותה רפליקה.
  • ‫disable_high_priority_cpu_autoscaling: מגדירים את disable_high_priority_cpu_autoscaling לערך TRUE אם לא רוצים שהכלי להתאמה אוטומטית של קנה המידה יתאים אוטומטית את קנה המידה של המעבד (CPU) בעדיפות גבוהה ברפליקות. אם רוצים שהמכונה תירש את היעד high_priority_cpu_autoscaling ממכונת הבסיס, לא צריך לציין את הפרמטר הזה. אי אפשר להשבית גם את סך כל המעבד (CPU) וגם את המעבד (CPU) בעדיפות גבוהה באותה רפליקה.

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

gcloud spanner instances update test-instance \
     --autoscaling-max-processing-units=10000

שינוי מכונה משימוש במידרוג אוטומטי מנוהל להתאמה ידנית

אתם יכולים לשנות את סוג ההתאמה של מכונה ב-Spanner (ידנית או מנוהלת) באמצעות מסוף Google Cloud , ה-CLI של gcloud או ספריות הלקוח של Spanner.

המסוף

1. נכנסים לדף Spanner Instances במסוף Google Cloud .

   כניסה לדף Instances

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

3. בקטע Choose a scaling mode, לוחצים על Manual allocation.

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

gcloud

משתמשים בפקודה gcloud spanner instances update כדי לעדכן את המכונה.

כדי לשנות מכונה משימוש ב-autoscaler מנוהל לשינוי קנה מידה ידני, משתמשים בפקודה הבאה:

  gcloud spanner instances update INSTANCE_ID \
  --processing-units=PROCESSING_UNIT_COUNT

או

  gcloud spanner instances update INSTANCE_ID \
  --nodes=NODE_COUNT

מחליפים את מה שכתוב בשדות הבאים:

• ‫INSTANCE_ID: המזהה הקבוע של המכונה.
• ‫NODE_COUNT: קיבולת המחשוב של המכונה, מבוטאת כמספר הצמתים. כל צומת שווה ל-1,000 יחידות עיבוד.
• ‫PROCESSING_UNIT_COUNT: קיבולת המחשוב של המכונה, מבוטאת כמספר יחידות עיבוד. כמויות של עד 1,000 צריך להזין בכפולות של 100 (100, 200, 300 וכן הלאה), וכמויות גדולות יותר צריך להזין בכפולות של 1,000 (1,000, 2,000, 3,000 וכן הלאה).

הוספת תווית למכונה

בעזרת התוויות אפשר לעשות סדר במשאבים.

המסוף

1. נכנסים לדף Spanner Instances במסוף Google Cloud .

   כניסה לדף Instances

2. מסמנים את התיבה של המכונה. חלונית המידע מופיעה בצד שמאל של הדף.

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

עריכת סוג ברירת המחדל של לוח הזמנים לגיבוי

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

המסוף

1. נכנסים לדף Spanner Instances במסוף Google Cloud .

כניסה לדף Instances

1. לוחצים על שם המכונה שרוצים לערוך את לוח הזמנים של הגיבוי שמוגדר לה כברירת מחדל.
2. לוחצים על Edit instance.
3. בקטע Backups, התיבה Enable default backup schedules קובעת אם לוחות הזמנים שמוגדרים כברירת מחדל לגיבוי מופעלים או לא. כשהאפשרות הזו מופעלת, לכל מסדי הנתונים החדשים במכונה הזו נוצר לוח זמנים לגיבוי כברירת מחדל.
4. לוחצים על Save.

gcloud

משתמשים בפקודה gcloud spanner instances update כדי לערוך את סוג לוחות הזמנים של הגיבויים שמוגדרים כברירת מחדל.

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

  gcloud spanner instances update INSTANCE_ID \
    --default-backup-schedule-type=DEFAULT_BACKUP_SCHEDULE_TYPE

מחליפים את מה שכתוב בשדות הבאים:

• ‫INSTANCE_ID: המזהה הקבוע של המכונה.

• ‫DEFAULT_BACKUP_SCHEDULE_TYPE: סוג ברירת המחדל של תזמון הגיבוי שמשמש במכונה. צריך לציין אחד מהערכים הבאים:

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

C#‎

במאמר ספריות הלקוח של Spanner מוסבר איך להתקין את ספריית הלקוח ולהשתמש בה ב-Spanner.

כדי לבצע אימות ב-Spanner, צריך להגדיר את Application Default Credentials. למידע נוסף, ראו הגדרת אימות לסביבת פיתוח מקומית.

using Google.Cloud.Spanner.Admin.Instance.V1;
using Google.Cloud.Spanner.Common.V1;
using Google.LongRunning;
using Google.Protobuf.WellKnownTypes;
using System;
using System.Threading.Tasks;

public class UpdateInstanceDefaultBackupScheduleTypeAsyncSample
{
    public async Task<Instance> UpdateInstanceDefaultBackupScheduleTypeAsync(string projectId, string instanceId)
    {
        // Create the InstanceAdminClient instance.
        InstanceAdminClient instanceAdminClient = await InstanceAdminClient.CreateAsync();

        // Initialize request parameters.
        Instance instance = new Instance
        {
            InstanceName = InstanceName.FromProjectInstance(projectId, instanceId),
            DefaultBackupScheduleType = Instance.Types.DefaultBackupScheduleType.Automatic,
        };
        FieldMask mask = new FieldMask 
        {
            Paths = { "default_backup_schedule_type" }
        };

        // Make the CreateInstance request.
        Operation<Instance, UpdateInstanceMetadata> response =
            await instanceAdminClient.UpdateInstanceAsync(instance, mask);

        Console.WriteLine("Waiting for the operation to finish.");

        // Poll until the returned long-running operation is complete.
        Operation<Instance, UpdateInstanceMetadata> completedResponse =
            await response.PollUntilCompletedAsync();

        if (completedResponse.IsFaulted)
        {
            Console.WriteLine($"Error while updating instance: {completedResponse.Exception}");
            throw completedResponse.Exception;
        }

        Console.WriteLine($"Instance updated successfully.");
        return completedResponse.Result;
    }
}

המשך

במאמר ספריות הלקוח של Spanner מוסבר איך להתקין את ספריית הלקוח ולהשתמש בה ב-Spanner.

כדי לבצע אימות ב-Spanner, צריך להגדיר את Application Default Credentials. למידע נוסף, ראו הגדרת אימות לסביבת פיתוח מקומית.

import (
	"context"
	"fmt"
	"io"

	instance "cloud.google.com/go/spanner/admin/instance/apiv1"
	"cloud.google.com/go/spanner/admin/instance/apiv1/instancepb"
	"google.golang.org/genproto/protobuf/field_mask"
)

// updateInstanceDefaultBackupScheduleType updates instance default backup schedule type to AUTOMATIC.
// This means a default backup schedule will be created automatically on creation of a database within the instance.
func updateInstanceDefaultBackupScheduleType(w io.Writer, projectID, instanceID string) error {
	// projectID := "my-project-id"
	// instanceID := "my-instance"
	ctx := context.Background()
	instanceAdmin, err := instance.NewInstanceAdminClient(ctx)
	if err != nil {
		return err
	}
	defer instanceAdmin.Close()

	// Updates the default backup schedule type field of an instance.  The field mask is required to
	// indicate which field is being updated.
	req := &instancepb.UpdateInstanceRequest{
		Instance: &instancepb.Instance{
			Name: fmt.Sprintf("projects/%s/instances/%s", projectID, instanceID),
			// Controls the default backup behavior for new databases within the instance.
			DefaultBackupScheduleType: instancepb.Instance_AUTOMATIC,
		},
		FieldMask: &field_mask.FieldMask{
			Paths: []string{"default_backup_schedule_type"},
		},
	}
	op, err := instanceAdmin.UpdateInstance(ctx, req)
	if err != nil {
		return fmt.Errorf("could not update instance %s: %w", fmt.Sprintf("projects/%s/instances/%s", projectID, instanceID), err)
	}
	// Wait for the instance update to finish.
	_, err = op.Wait(ctx)
	if err != nil {
		return fmt.Errorf("waiting for instance update to finish failed: %w", err)
	}

	fmt.Fprintf(w, "Updated instance [%s]\n", instanceID)
	return nil
}

Java

במאמר ספריות הלקוח של Spanner מוסבר איך להתקין את ספריית הלקוח ולהשתמש בה ב-Spanner.

כדי לבצע אימות ב-Spanner, צריך להגדיר את Application Default Credentials. למידע נוסף, ראו הגדרת אימות לסביבת פיתוח מקומית.

import com.google.cloud.spanner.Spanner;
import com.google.cloud.spanner.SpannerOptions;
import com.google.cloud.spanner.admin.instance.v1.InstanceAdminClient;
import com.google.common.collect.Lists;
import com.google.protobuf.FieldMask;
import com.google.spanner.admin.instance.v1.Instance;
import com.google.spanner.admin.instance.v1.InstanceConfigName;
import com.google.spanner.admin.instance.v1.InstanceName;
import com.google.spanner.admin.instance.v1.UpdateInstanceRequest;
import java.util.concurrent.ExecutionException;

public class UpdateInstanceDefaultBackupScheduleTypeExample {

  static void updateInstanceDefaultBackupScheduleType() {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "my-project";
    String instanceId = "my-instance";
    updateInstanceDefaultBackupScheduleType(projectId, instanceId);
  }

  static void updateInstanceDefaultBackupScheduleType(String projectId, String instanceId) {
    // Set Instance configuration.
    int nodeCount = 2;
    String displayName = "Updated name";

    // Update an Instance object that will be used to update the instance.
    Instance instance =
        Instance.newBuilder()
            .setName(InstanceName.of(projectId, instanceId).toString())
            .setDisplayName(displayName)
            .setNodeCount(nodeCount)
            .setDefaultBackupScheduleType(Instance.DefaultBackupScheduleType.AUTOMATIC)
            .setConfig(InstanceConfigName.of(projectId, "regional-us-east4").toString())
            .build();

    try (Spanner spanner =
            SpannerOptions.newBuilder().setProjectId(projectId).build().getService();
        InstanceAdminClient instanceAdminClient = spanner.createInstanceAdminClient()) {

      // Wait for the updatedInstance operation to finish.
      Instance updatedInstance =
          instanceAdminClient
              .updateInstanceAsync(
                  UpdateInstanceRequest.newBuilder()
                      .setFieldMask(
                          FieldMask.newBuilder()
                              .addAllPaths(Lists.newArrayList("default_backup_schedule_type")))
                      .setInstance(instance)
                      .build())
              .get();
      System.out.printf("Instance %s was successfully updated%n", updatedInstance.getName());
    } catch (ExecutionException e) {
      System.out.printf(
          "Error: Updating instance %s failed with error message %s%n",
          instance.getName(), e.getMessage());
    } catch (InterruptedException e) {
      System.out.println("Error: Waiting for updateInstance operation to finish was interrupted");
    }
  }
}

Node.js

במאמר ספריות הלקוח של Spanner מוסבר איך להתקין את ספריית הלקוח ולהשתמש בה ב-Spanner.

כדי לבצע אימות ב-Spanner, צריך להגדיר את Application Default Credentials. למידע נוסף, ראו הגדרת אימות לסביבת פיתוח מקומית.

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// const projectId = 'my-project-id';
// const instanceId = 'my-instance';

// Imports the Google Cloud client library
const {Spanner, protos} = require('@google-cloud/spanner');

// Creates a client
const spanner = new Spanner({
  projectId: projectId,
});
const instanceAdminClient = await spanner.getInstanceAdminClient();

// Updates an instance
try {
  const [operation] = await instanceAdminClient.updateInstance({
    instance: {
      name: instanceAdminClient.instancePath(projectId, instanceId),
      defaultBackupScheduleType:
        protos.google.spanner.admin.instance.v1.Instance
          .DefaultBackupScheduleType.AUTOMATIC, // optional
    },
    // Field mask specifying fields that should get updated in an Instance
    fieldMask: (protos.google.protobuf.FieldMask = {
      paths: ['default_backup_schedule_type'],
    }),
  });

  await operation.promise();
  const [metadata] = await instanceAdminClient.getInstance({
    name: instanceAdminClient.instancePath(projectId, instanceId),
  });
  console.log(
    `Instance ${instanceId} has been updated with the ${metadata.defaultBackupScheduleType}` +
      ' default backup schedule type.',
  );
} catch (err) {
  console.error('ERROR:', err);
}

Python

במאמר ספריות הלקוח של Spanner מוסבר איך להתקין את ספריית הלקוח ולהשתמש בה ב-Spanner.

כדי לבצע אימות ב-Spanner, צריך להגדיר את Application Default Credentials. למידע נוסף, ראו הגדרת אימות לסביבת פיתוח מקומית.

def update_instance_default_backup_schedule_type(instance_id):
    spanner_client = spanner.Client()

    name = "{}/instances/{}".format(spanner_client.project_name, instance_id)

    operation = spanner_client.instance_admin_api.update_instance(
        instance=spanner_instance_admin.Instance(
            name=name,
            default_backup_schedule_type=spanner_instance_admin.Instance.DefaultBackupScheduleType.AUTOMATIC,  # Optional
        ),
        field_mask=field_mask_pb2.FieldMask(paths=["default_backup_schedule_type"]),
    )

    print("Waiting for operation to complete...")
    operation.result(OPERATION_TIMEOUT_SECONDS)

    print("Updated instance {} to have default backup schedules".format(instance_id))

העברת מכונה

הערה: אי אפשר להעביר מכונה שהופעל בה מידרוג אוטומטי מנוהל.

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

מחיקת מכונה

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

אפשר למחוק מכונה באמצעות מסוף Google Cloud או ה-CLI של gcloud.

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

המסוף

1. נכנסים לדף Spanner Instances במסוף Google Cloud .

   כניסה לדף Instances

2. לוחצים על השם של המכונה שרוצים למחוק.

3. לוחצים על Delete instance.

4. פועלים לפי ההוראות כדי לאשר שרוצים למחוק את המכונה.

5. לוחצים על Delete.

gcloud

מריצים את הפקודה gcloud spanner instances delete, ומחליפים את INSTANCE_ID במזהה המכונה:

gcloud spanner instances delete INSTANCE_ID

עצירה או הפעלה מחדש של מכונה

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

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

• איך מוסיפים, מעדכנים ומוחקים נתונים באמצעות שפת טיפול בנתונים (DML) או ה-CLI של gcloud.
• להקצות תפקידים של ניהול זהויות והרשאות גישה (IAM) למכונה ולמסדי הנתונים שלה.
• איך מתכננים סכימה של Spanner