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

בדף הזה מוסבר איך ליצור, להציג, לערוך ולמחוק מופעים של 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 (אזורי), Dual-region (בשני אזורים) או Multi-region (במספר אזורים).

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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 וכן הלאה). הערה: אל תשתמשו בפרמטר הזה אם אתם יוצרים מופע שאתם מתכוונים להפעיל בו את קנה המידה האוטומטי המנוהל בהמשך.

הוספת קנה מידה אוטומטי מנוהל

אפשר גם ליצור מכונות במהדורת 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 \
    [--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 \
    [--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: המספר המינימלי של יחידות עיבוד או צמתים כשמצמצמים את קנה המידה. מידע נוסף מופיע במאמר בנושא קביעת המגבלה המינימלית.
• ‫MAXIMUM_PROCESSING_UNITS, MAXIMUM_NODES: המספר המקסימלי של יחידות עיבוד או צמתים בהגדלת הקיבולת. מידע נוסף מופיע במאמר בנושא קביעת המגבלה המקסימלית.
• ‫HIGH_PRIORITY_CPU_PERCENTAGE: אחוז היעד של השימוש ב-CPU בעדיפות גבוהה, על סמך העדיפות של המשימה. אחוז השימוש במעבד יכול להיות בין 10% ל-90%. אם אתם מבצעים אופטימיזציה להפחתת העלויות, כדאי להשתמש באחוז גבוה יותר. מידע נוסף זמין במאמר בנושא קביעת יעד גבוה לניצול המעבד.
• ‫TOTAL_CPU_PERCENTAGE: אחוז היעד של סך המעבד בעדיפות לשימוש. יעד המעבד הכולל צריך להיות גדול מיעד המעבד בעדיפות גבוהה. אחוז השימוש במעבד יכול להיות בין 10% ל-90%. אם אתם מבצעים אופטימיזציה לעלות, כדאי להשתמש באחוז גבוה יותר. מידע נוסף זמין במאמר קביעת יעד לניצול כולל של CPU.
• ‫STORAGE_PERCENTAGE: אחוז האחסון שרוצים להשתמש בו, מ-10% עד 99%. מידע נוסף זמין במאמר בנושא קביעת יעד לניצול נפח האחסון.

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

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

  • ‫ASYMMETRIC_AUTOSCALING_LOCATION: אם משתמשים בדגל, הפרמטר הזה נדרש. המיקום של האזור לקריאה בלבד שרוצים לשנות את הגודל שלו באופן לא סימטרי.
  • ‫ASYMMETRIC_AUTOSCALING_MIN: פרמטר אופציונלי. המספר המינימלי של צמתים כשמצמצמים את הקיבולת. אם לא מציינים ערך, הוא עובר בירושה מההגדרה של מופע הבסיס.
  • ‫ASYMMETRIC_AUTOSCALING_MAX: פרמטר אופציונלי. המספר המקסימלי של צמתים בהגדלת הקיבולת. אם לא מציינים ערך, הוא עובר בירושה מההגדרה של מופע הבסיס.
  • ‫ASYMMETRIC_HIGH_PRIORITY_CPU_TARGET: פרמטר אופציונלי. אחוז המעבד שרוצים להשתמש בו, על סמך העדיפות של המשימה. אם לא מציינים ערך, הערך הזה עובר בירושה מהגדרות מופע הבסיס. אם אתם מבצעים אופטימיזציה של העלות, כדאי להשתמש באחוז גבוה יותר. יכול להיות שלעותקים יהיה אחוז יעד שונה מזה של מופע הבסיס ומעותקים אחרים, אבל בתרחישי מעבר לגיבוי, מומלץ שהעותקים ישתמשו ביעדים עקביים בכל העותקים השונים. מידע נוסף זמין במאמר בנושא בעיות שקשורות למעבר לגיבוי בעת כשל.
  • ‫ASYMMETRIC_TOTAL_CPU_TARGET: פרמטר אופציונלי. מגדירים את היעד מ-10% ל-90% עבור total CPU. אם לא מציינים ערך, הערך הזה עובר בירושה מהגדרות מופע הבסיס. אם אתם מבצעים אופטימיזציה של העלות, כדאי להשתמש באחוז גבוה יותר. יכול להיות שלעותקים יהיה אחוז יעד שונה מזה של מופע הבסיס ומעותקים אחרים, אבל בתרחישי מעבר לגיבוי, מומלץ שהעותקים ישתמשו ביעדים עקביים בכל העותקים השונים. מידע נוסף מופיע במאמר בנושא שינוי גודל אוטומטי אסימטרי לקריאה בלבד.
  • ‫disable_total_cpu_autoscaling: מגדירים את הפרמטר הזה לערך TRUE אם לא רוצים שהכלי לשינוי קנה מידה אוטומטי ישנה את קנה המידה של סך השימוש במעבד ברפליקות באופן אוטומטי. אם רוצים שהמופע יקבל בירושה את total_cpu_autoscaling היעד ממופע הבסיס, לא מציינים את הפרמטר הזה. אי אפשר להשבית גם את השימוש הכולל במעבד וגם את השימוש במעבד בעדיפות גבוהה באותה רפליקה.
  • ‫disable_high_priority_cpu_autoscaling: מגדירים את הערך disable_high_priority_cpu_autoscaling ל-TRUE אם לא רוצים שהכלי לשינוי קנה מידה אוטומטי ישנה את קנה המידה של השימוש ב-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;
    }
}

Go

מידע על התקנת ספריית הלקוח של 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
}

יצירת מכונה עם שינוי גודל אוטומטי מנוהל באמצעות 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");
    }
  }
}

יצירת מופע עם שינוי גודל אוטומטי מנוהל באמצעות 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.

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"
)

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. בדף סקירה כללית של המכונה, לוחצים על עריכת המכונה.

4. בדף עריכת מופע, בקטע בחירת מהדורת Spanner, בוחרים במהדורה ברמה נמוכה יותר.

5. לוחצים על עדכון המופע.

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. לוחצים על עריכת מופע.

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 הפרויקט.

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

צריך להקצות מספיק קיבולת מחשוב כדי שניצול המעבד וניצול האחסון יהיו מתחת למקסימום המומלץ. מידע נוסף זמין במאמר מכסות ומגבלות ב-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. לוחצים על עריכת מופע.

4. בקטע Configure compute capacity (הגדרת קיבולת מחשוב), לוחצים על Autoscaling (שינוי גודל אוטומטי).

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

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

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

8. בקטע יעד ניצול כולל של המעבד, בוחרים את אחוז המעבד שרוצים להשתמש בו עבור כל המשימות בעדיפות נמוכה, בינונית וגבוהה. אחוז השימוש במעבד יכול להיות בין 10% ל-90%. מידע נוסף זמין במאמר בנושא קביעת יעד כולל לניצול מעבד.

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

10. אופציונלי: אם בוחרים באפשרות התאמה אוטומטית לעומס (automatic scaling) כמצב שינוי הגודל, אפשר ללחוץ על התפריט הנפתח הצגת אפשרויות של התאמה אוטומטית לעומס (automatic scaling) אסימטרית כדי לשנות את הגודל של הרפליקות לקריאה בלבד באופן אוטומטי, בנפרד מרפליקות אחרות.

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

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

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

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 \
    [--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 \
    [--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: המספר המינימלי של יחידות עיבוד או צמתים לשימוש בהקטנת קנה המידה. מידע נוסף מופיע במאמר בנושא קביעת המגבלה המינימלית.
• ‫MAXIMUM_PROCESSING_UNITS, MAXIMUM_NODES: מספר יחידות העיבוד או הצמתים המקסימליים לשימוש בהגדלת הקיבולת. מידע נוסף זמין במאמר בנושא קביעת המגבלה המקסימלית.
• ‫HIGH_PRIORITY_CPU_PERCENTAGE: אחוז היעד של השימוש ב-CPU בעדיפות גבוהה, על סמך העדיפות של המשימה. אחוז השימוש במעבד יכול להיות בין 10% ל-90%. אם אתם מבצעים אופטימיזציה להפחתת העלויות, כדאי להשתמש באחוז גבוה יותר. מידע נוסף זמין במאמר בנושא קביעת יעד גבוה לניצול המעבד.
• ‫TOTAL_CPU_PERCENTAGE: אחוז היעד של סך המעבד בעדיפות לשימוש. יעד המעבד הכולל צריך להיות גדול מיעד המעבד בעדיפות גבוהה. אחוז השימוש במעבד יכול להיות בין 10% ל-90%. אם אתם מבצעים אופטימיזציה לעלות, כדאי להשתמש באחוז גבוה יותר. מידע נוסף זמין במאמר קביעת יעד לניצול כולל של CPU.
• ‫STORAGE_PERCENTAGE: אחוז האחסון שרוצים להשתמש בו, מ-10% עד 99%. מידע נוסף זמין במאמר בנושא קביעת יעד לניצול נפח האחסון.

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

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

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

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

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

gcloud

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

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

  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. לוחצים על עריכת מופע.
3. בקטע גיבויים, תיבת הסימון הפעלת לוחות זמנים לגיבוי כברירת מחדל קובעת אם לוחות הזמנים לגיבוי כברירת מחדל מופעלים או לא. אם האפשרות הזו מופעלת, לכל מסדי הנתונים החדשים במופע הזה נוצר לוח זמנים לגיבוי כברירת מחדל.
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;
    }
}

Go

מידע על התקנת ספריית הלקוח של 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 או Google Cloud CLI.

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

המסוף

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

   כניסה לדף Instances

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

3. לוחצים על מחיקת המופע.

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

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

gcloud

משתמשים בפקודה gcloud spanner instances delete ומחליפים את INSTANCE_ID במזהה המופע:

gcloud spanner instances delete INSTANCE_ID

הפסקה או הפעלה מחדש של מכונה

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

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

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