יצירת מכונה

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

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

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

הכנת הסביבה:

1. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

   Roles required to select or create a project

   • Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
   • Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.
   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

2. Verify that billing is enabled for your Google Cloud project.

3. Enable the Cloud Bigtable API, Cloud Bigtable Admin API APIs, if any are not already enabled.

   Roles required to enable APIs

   To enable APIs, you need the serviceusage.services.enable permission. If you created the project, then you likely already have this permission through the Owner role (roles/owner). Otherwise, you can get this permission through the Service Usage Admin role (roles/serviceusage.serviceUsageAdmin). Learn how to grant roles.

   Enable the APIs

4. Install the Google Cloud CLI.

   Note: If you installed the gcloud CLI previously, make sure you have the latest version by running gcloud components update.

5. Configure the gcloud CLI to use your federated identity.

   For more information, see Sign in to the gcloud CLI with your federated identity.

6. To initialize the gcloud CLI, run the following command:

   gcloud init

7. מריצים את הפקודה הבאה כדי להתקין את ה-CLI של cbt:

   gcloud components install cbt

תכנון ההגדרות האישיות:

1. אופציונלי: אם אתם מתכננים להפעיל רפליקציה, בצעו את הפעולות הבאות:

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

2. אופציונלי: אם אתם רוצים להשתמש במפתחות הצפנה בניהול הלקוח (CMEK) במקום בהצפנה שמוגדרת כברירת מחדל ומנוהלת על ידי Google, ודאו שמזהה מפתח ה-CMEK מוכן לפני שאתם יוצרים את המכונה החדשה. אי אפשר להוסיף הגנת CMEK למכונה אחרי שהיא נוצרה, ואי אפשר לשנות או להחליף את מפתח ה-CMEK אחרי שהמכונה נוצרה. מידע נוסף מופיע במאמר שימוש במפתחות הצפנה בניהול הלקוח (CMEK).

יצירת מכונה

כדי ליצור מכונה של Bigtable:

המסוף

1. נכנסים לדף Create instance במסוף Google Cloud .

   כניסה לדף Create instance

2. נותנים שם למכונה.

   השם הזה מופיע במסוף Google Cloud כדי לזהות את המכונה.

3. צריך להזין מזהה מכונה.

   מזהה המכונה הוא מזהה קבוע של המכונה.

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

5. בקטע Select your edition, בוחרים מהדורה של Bigtable.

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

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

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

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

9. מזינים מזהה לאשכול הראשון.

   מזהה האשכול הוא מזהה קבוע של האשכול.

10. בוחרים את האזור והתחום שבהם האשכול הראשון יפעל.

11. אופציונלי: כדי להגדיר את האשכול כך שתמיד יתבצע שינוי קנה מידה במרווחים של שני צמתים, בוחרים באפשרות Enable 2x node scaling. אי אפשר להגדיל את הצומת פי 2 בכל האזורים. במהדורת Enterprise Plus, האפשרות שמוגדרת כברירת מחדל היא הגדלת מספר הצמתים פי 2. מידע נוסף זמין במאמר גורם לקביעת קנה מידה של צומת.

12. אופציונלי: כדי להשתמש בשכבה בזיכרון ברמת האשכול, בוחרים באפשרות Enable in-memory.

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

    1. בקטע Manual node allocation, מזינים את מספר הצמתים של Bigtable באשכול הראשון. אם אתם לא בטוחים כמה צמתים אתם צריכים, השתמשו בברירת המחדל. אפשר להוסיף עוד צמתים בהמשך.
    2. בשדה Autoscaling, מזינים ערכים בשדות הבאים:
       • מספר הצמתים המינימלי
       • מספר הצמתים המקסימלי
       • יעד ניצול המעבד (CPU)
       • יעד ניצול נפח האחסון

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

    1. לוחצים על הצגת אפשרויות ההצפנה.
    2. בוחרים באפשרות Cloud KMS key.
    3. בשדה Key management type, בוחרים אחת מהאפשרויות הבאות:
       • אם רוצים ליצור מפתחות Cloud KMS באופן אוטומטי, בוחרים באפשרות Cloud KMS with Autokey ולוחצים על Request a key. תופיע הודעה כשהמפתח נוצר בהצלחה ומוכן לשימוש.
       • אם רוצים להוסיף מפתח באופן ידני, בוחרים באפשרות Cloud KMS. בוחרים או מזינים את שם המשאב של מפתח ה-CMEK שבו רוצים להשתמש באשכול. אי אפשר להוסיף את זה אחר כך. אם מוצגת בקשה לתת הרשאה לחשבון השירות של מפתח ה-CMEK, לוחצים על Grant. כדי לבצע את המשימה הזו, צריך להקצות לחשבון המשתמש את התפקיד "אדמין ב-Cloud KMS". לוחצים על Save.

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

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

    כל אזור בתחום יכול להכיל רק אשכול אחד. אם הלחצן Add cluster מושבת, צריך לשנות את האזור של האשכול הראשון.

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

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

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

gcloud

1. משתמשים בפקודה bigtable instances create כדי ליצור מכונה:

   gcloud bigtable instances create INSTANCE_ID \
       --display-name=DISPLAY_NAME \
       [--edition=EDITION] \
       [--cluster-storage-type=CLUSTER_STORAGE_TYPE] \
       [--cluster-config=id=CLUSTER_ID,zone=CLUSTER_ZONE, \
       nodes=NODES] \
       [--cluster-config=id=CLUSTER_ID,zone=CLUSTER_ZONE, \
       autoscaling-min-nodes=AUTOSCALING_MIN_NODES, \
       autoscaling-max-nodes=AUTOSCALING_MAX_NODES, \
       autoscaling-cpu-target=AUTOSCALING_CPU_TARGET, \
       autoscaling-storage-target=AUTOSCALING_STORAGE_TARGET, \
       kms-key=KMS_KEY], \
       [node-scaling-factor=NODE_SCALING_FACTOR]
   

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

   • INSTANCE_ID: המזהה הקבוע של המכונה
   • ‫DISPLAY_NAME: שם קריא לאנשים שמזהה את המכונה במסוף Google Cloud .
   • CLUSTER_ID: המזהה הקבוע של האשכול
   • ‫CLUSTER_ZONE: האזור שבו פועל האשכול.

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

   בהקצאת צמתים ידנית, הגדרת nodes בדגל --cluster-config היא אופציונלית. אם לא מגדירים ערך, Bigtable מקצה צמתים לאשכול באופן אוטומטי על סמך טביעת הרגל של הנתונים, ומבצע אופטימיזציה לניצול של 50% מהאחסון. להקצאה האוטומטית הזו של צמתים יש השפעה על התמחור. אם רוצים לשלוט במספר הצמתים באשכול, מחליפים את NODES במספר הצמתים שרוצים באשכול. מידע נוסף על צמתים

   ברוב המקרים, כדאי לבחור בהתאמה לעומס (autoscaling) במקום בהקצאת צמתים ידנית. ב-autoscaling, צריך לספק אפשרויות של autoscaling- בדגל --cluster-config (autoscaling-storage-target הוא אופציונלי) ולא להשתמש ב-nodes. במאמר התאמה אוטומטית לעומס מוסבר איך לבחור את הערכים של הגדרות ההתאמה האוטומטית לעומס. מחליפים את הערכים הבאים במקשי האפשרויות של cluster-config:

   • ‫AUTOSCALING_MIN_NODES: המספר המינימלי של צמתים באשכול.
   • ‫AUTOSCALING_MAX_NODES: המספר המקסימלי של צמתים באשכול.
   • ‫AUTOSCALING_CPU_TARGET: אחוז היעד של ניצול המעבד (CPU) באשכול. הערך צריך להיות בין 10 ל-80.
   • ‫AUTOSCALING_STORAGE_TARGET: (אופציונלי) יעד ניצול האחסון ב-GiB ש-Bigtable שומר על ידי הוספה או הסרה של צמתים.

   • ‫KMS_KEY: מפתח ה-CMEK של האשכול.

     צריך להגדיר את הערך KMS_KEY בפורמט הבא:

     projects/PROJECT/locations/LOCATION/keyRings/KEYRING/cryptoKeys/KEY
     

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

     • ‫PROJECT: המזהה הקבוע של הפרויקט
     • ‫LOCATION: המיקום של האשכול
     • ‫KEYRING: השם של אוסף המפתחות שמכיל את המפתח
     • ‫KEY: השם של המפתח

     לדוגמה:

     projects/examplestore.com:dev/locations/us-east1/keyRings/devt-cmek-2/cryptoKeys/key2

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

   הפקודה מקבלת את הדגלים האופציונליים הבאים:

   • ‫--edition=EDITION: המהדורה של המכונה שיוצרים. הערכים הקבילים הם ENTERPRISE ו-ENTERPRISE_PLUS. ערך ברירת המחדל הוא ENTERPRISE.

   • ‫--cluster-storage-type=CLUSTER_STORAGE_TYPE: סוג האחסון שבו משתמשים במכונה. ערך ברירת המחדל הוא SSD. ברוב המקרים, ערך ברירת המחדל הוא הטוב ביותר. הבחירה הזו היא סופית. מידע נוסף

   • ‫--project=PROJECT: הפרויקט שבו רוצים ליצור את האשכול, אם הוא שונה מהפרויקט הנוכחי.

   • ‫node-scaling-factor=NODE_SCALING_FACTOR: דגל שמפעיל שינוי קנה מידה של צומת פי 2. אפשר להפעיל את התכונה הזו גם עם התאמה ידנית וגם עם התאמה אוטומטית לעומס. הערכים הקבילים הם node-scaling-factor-2x או node-scaling-factor-1x.

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

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

     • שימוש במזהים קבועים:
       --tags=tagKeys/984321798431=tagValues/567890123456,
tagKeys/123456789012=tagValues/098765432109
     • שימוש בשמות ממרחבי שמות:
       --tags=123456789012/environment=123456789012/environment/prod,
123456789012/costcenter=123456789012/costcenter/marketing

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

cbt

הערה: אי אפשר ליצור משאבים שמוגנים באמצעות CMEK או להגדיר התאמה אוטומטית לעומס באמצעות cbt CLI. בנוסף, אי אפשר להפעיל את הגדלת הצומת פי 2 באמצעות cbt CLI.

1. קודם כל יוצרים מכונה עם אשכול אחד. משתמשים בפקודה createinstance כדי ליצור מכונה:

   cbt createinstance INSTANCE_ID \
       DISPLAY_NAME \
       CLUSTER_ID \
       CLUSTER_ZONE \
       CLUSTER_NUM_NODES \
       CLUSTER_STORAGE_TYPE
   

   מזינים את הפרטים הבאים:

   • INSTANCE_ID: המזהה הקבוע של המכונה
   • ‫DISPLAY_NAME: שם קריא לאנשים שמזהה את המכונה במסוף Google Cloud .
   • CLUSTER_ID: המזהה הקבוע של האשכול
   • ‫CLUSTER_ZONE: האזור שבו פועל האשכול.
   • ‫CLUSTER_NUM_NODES: השדה הזה הוא אופציונלי. אם לא מגדירים ערך, Bigtable מקצה צמתים באופן אוטומטי על סמך נפח הנתונים ומבצע אופטימיזציה לניצול של 50% מהאחסון. כדי לשלוט במספר הצמתים באשכול, מעדכנים את הערך של CLUSTER_NUM_NODES. מוודאים שמספר הצמתים מוגדר לערך שאינו אפס. מידע נוסף על צמתים
   • ‫CLUSTER_STORAGE_TYPE: סוג האחסון שבו משתמשים באשכול. כל אשכול במכונה חייב להשתמש באותו סוג אחסון. אפשר להזין את הערכים SSD ו-HDD. ברוב המקרים, SSD היא האפשרות הטובה ביותר. הבחירה הזו היא סופית. מידע נוסף

2. כדי להפעיל את הרפליקציה, משתמשים בפקודה createcluster כדי להוסיף אשכול:

   
   cbt -instance=INSTANCE_ID \
   createcluster CLUSTER_ID \
   ZONE \
   NUM_NODES \
   STORAGE_TYPE
   
   

   מזינים את הפרטים הבאים:

   • ‫INSTANCE_ID: המזהה הקבוע של המכונה שיצרתם
   • CLUSTER_ID: המזהה הקבוע של האשכול

   • ‫ZONE: האזור שבו פועל האשכול.

     כל אזור בתחום יכול להכיל רק אשכול אחד. לדוגמה, אם למכונה יש אשכול ב-us-east1-b, אתם יכולים להוסיף אשכול באזור אחר באותו מחוז, כמו us-east1-c, או באזור במחוז נפרד, כמו europe-west2-a.

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

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

   • ‫STORAGE_TYPE: סוג האחסון שבו משתמשים באשכול. כל אשכול במכונה חייב להשתמש באותו סוג אחסון. אפשר להזין את הערכים SSD ו-HDD.

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

C++‎

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

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

namespace cbta = ::google::cloud::bigtable_admin;
using ::google::cloud::future;
using ::google::cloud::Location;
using ::google::cloud::Project;
using ::google::cloud::StatusOr;
[](cbta::BigtableInstanceAdminClient instance_admin,
   std::string const& project_id, std::string const& instance_id,
   std::string const& zone) {
  auto const project = Project(project_id);
  std::string project_name = project.FullName();
  std::string cluster_id = instance_id + "-c1";

  google::bigtable::admin::v2::Instance in;
  in.set_type(google::bigtable::admin::v2::Instance::PRODUCTION);
  in.set_display_name("Put description here");

  google::bigtable::admin::v2::Cluster cluster;
  cluster.set_location(Location(project, zone).FullName());
  cluster.set_serve_nodes(3);
  cluster.set_default_storage_type(google::bigtable::admin::v2::HDD);

  std::map<std::string, google::bigtable::admin::v2::Cluster> cluster_map = {
      {cluster_id, std::move(cluster)}};

  future<StatusOr<google::bigtable::admin::v2::Instance>> instance_future =
      instance_admin.CreateInstance(project_name, instance_id, std::move(in),
                                    std::move(cluster_map));
  // Show how to perform additional work while the long running operation
  // completes. The application could use future.then() instead.
  std::cout << "Waiting for instance creation to complete " << std::flush;
  instance_future.wait_for(std::chrono::seconds(1));
  std::cout << '.' << std::flush;
  auto instance = instance_future.get();
  if (!instance) throw std::move(instance).status();
  std::cout << "DONE, details=" << instance->DebugString() << "\n";
}

C#‎

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

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

// Creates a production instance with "<intanceId>-prod" instance ID,
// with cluster ID "ssd-cluster1", 3 nodes and location us-east1-b.
displayName += " Prod"; // Display name is for display purposes only. It doesn't have to equal instanceId and can be amended after instance is created.
string instanceId = Regex.Replace(displayName, @"[^A-Za-z0-9_\.~]+", "-").ToLower();

// Please refer to the link below for the full list of available locations:
// https://cloud.google.com/bigtable/docs/locations
string zone1 = "us-east1-b";

// The instance to create.
Instance myInstance = new Instance
{
    DisplayName = displayName,
    // You can choose DEVELOPMENT or PRODUCTION type here.
    // If not set, will default to PRODUCTION type.
    // Instance type can be upgraded from DEVELOPMENT to PRODUCTION but cannot be dowgraded after the instance is created.
    Type = Instance.Types.Type.Production,
    Labels = { { "prod-label", "prod-label" } }
};

// The first cluster to be created within the instance.
Cluster myCluster1 = new Cluster
{
    // You can choose SSD or HDD storage type here: StorageType.Ssd or StorageType.Hdd.
    // Cluster storage type can not be changed after the instance is created.
    // If not set will default to SSD type.
    DefaultStorageType = StorageType.Ssd,
    LocationAsLocationName = new LocationName(projectId, zone1),
    // Serve Nodes count can only be set if PRODUCTION type instance is being created.
    // Minimum count of 3 serve nodes must be specified.
    // Serve Nodes count can be increased and decreased after an instance is created.
    ServeNodes = 3
};

// Initialize request argument(s).
CreateInstanceRequest request = new CreateInstanceRequest
{
    ParentAsProjectName = new ProjectName(projectId),
    Instance = myInstance,
    InstanceId = instanceId,
    // Must specify at lease one cluster.
    // Only PRODUCTION type instance can be created with more than one cluster.
    // Currently all clusters must have the same storage type.
    // Clusters must be set to different locations.
    Clusters = { { "ssd-cluster1", myCluster1 } }
};

try
{
    // Make a request.
    Operation<Instance, CreateInstanceMetadata> createInstanceResponse =
        bigtableInstanceAdminClient.CreateInstance(request);
    Console.WriteLine("Waiting for operation to complete...");

    // Poll until the returned long-running operation is complete
    Operation<Instance, CreateInstanceMetadata> completedResponse =
        createInstanceResponse.PollUntilCompleted();
}
catch (Exception ex)
{
    Console.WriteLine($"Exception while creating {displayName} instance");
    Console.WriteLine(ex.Message);
}

המשך

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

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

// Copyright 2026 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

// Instance admin is a sample program demonstrating use of the Cloud Bigtable client
// library to perform basic instance admin operations.
package main

import (
	"context"
	"flag"
	"fmt"
	"io"
	"os"

	"cloud.google.com/go/bigtable"
)

func main() {
	projectID := "my-project-id" // The Google Cloud Platform project ID
	instanceID := "my-bigtable-instance"
	clusterID := "my-cluster"
	zone := "us-central1-b"

	// Allow overriding with flags
	flag.StringVar(&projectID, "project", projectID, "The Google Cloud Platform project ID.")
	flag.StringVar(&instanceID, "instance", instanceID, "The Google Cloud Bigtable instance ID to create.")
	flag.StringVar(&zone, "zone", zone, "The zone for the initial cluster.")
	flag.Parse()

	if err := createInstance(os.Stdout, projectID, instanceID, clusterID, zone); err != nil {
		fmt.Fprintf(os.Stderr, "Error creating instance: %v", err)
	}
}

func createInstance(w io.Writer, projectID, instanceID, clusterID, zone string) error {
	ctx := context.Background()

	instanceAdminClient, err := bigtable.NewInstanceAdminClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("bigtable.NewInstanceAdminClient: %w", err)
	}
	defer instanceAdminClient.Close()

	// These are placeholders. You must create these in your GCP Organization/Project first.
	// See [Creating and managing tags](https://docs.cloud.google.com/bigtable/docs/tags) for
	// more information on creating a tag.
	// tagKey := "tagKeys/12345"
	// tagValue := "tagValues/56789"

	instanceConf := &bigtable.InstanceConf{
		InstanceId:   instanceID,
		DisplayName:  instanceID,
		ClusterId:    clusterID,
		NumNodes:     1,
		InstanceType: bigtable.PRODUCTION,
		StorageType:  bigtable.SSD,
		Zone:         zone,
		// The 'Tags' field is optional. Uncomment the lines below (and the tagKey, tagValue lines above)
		// only if you want to create an instance with tags.
		// Ensure the tagKey and tagValue exist in your GCP project.
		// Tags: map[string]string{tagKey: tagValue},
	}

	fmt.Fprintf(w, "Creating instance %s with cluster %s in %s...\n", instanceID, clusterID, zone)

	if err := instanceAdminClient.CreateInstance(ctx, instanceConf); err != nil {
		return fmt.Errorf("CreateInstance: %w", err)
	}

	fmt.Fprintf(w, "Instance %s created successfully.\n", instanceID)
	return nil
}

Java

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

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

// Creates a Production Instance with the ID "ssd-instance",
// cluster id "ssd-cluster", 3 nodes and location "us-central1-f".
String parent = "projects/" + projectId;
Instance.Builder instanceObjBuilder =
    Instance.newBuilder()
        .setDisplayName(instanceId)
        .setType(Instance.Type.PRODUCTION)
        .putLabels("department", "accounting");

if (createWithTags) {
  System.out.println("Enabling tags for instance creation.");
  // These are placeholders. You must create these in your GCP Organization/Project first.
  String tagKey = "tagKeys/12345";
  String tagValue = "tagValues/6789";
  instanceObjBuilder.putTags(tagKey, tagValue);
}
Instance instanceObj = instanceObjBuilder.build();

Cluster clusterObj =
    Cluster.newBuilder()
        .setLocation("projects/" + projectId + "/locations/us-central1-f")
        .setServeNodes(3)
        .setDefaultStorageType(StorageType.SSD)
        .build();
CreateInstanceRequest request =
    CreateInstanceRequest.newBuilder()
        .setParent(parent)
        .setInstanceId(instanceId)
        .setInstance(instanceObj)
        .putClusters(clusterId, clusterObj)
        .build();
// Creates a production instance with the given request.
try {
  Instance instance = adminClient.createInstanceAsync(request).get();
  System.out.printf("PRODUCTION type instance %s created successfully%n", instance.getName());
} catch (Exception e) {
  System.err.println("Failed to create instance: " + e.getMessage());
  throw new RuntimeException(e);
}

Node.js

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

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

// Creates a Production Instance with the ID "ssd-instance"
// with cluster id "ssd-cluster", 3 nodes and location us-central1-f
const {BigtableInstanceAdminClient} = require('@google-cloud/bigtable').v2;
const instanceAdminClient = new BigtableInstanceAdminClient();
const projectId = await instanceAdminClient.getProjectId();

const instanceOptions = {
  parent: `projects/${projectId}`,
  instanceId: instanceID,
  instance: {
    displayName: instanceID,
    labels: {'prod-label': 'prod-label'},
    type: 'PRODUCTION',
  },
  clusters: {
    [clusterID]: {
      location: `projects/${projectId}/locations/us-central1-f`,
      serveNodes: 3,
      defaultStorageType: 'SSD',
    },
  },
};

// Create production instance with given options
const [prodInstance, operation] =
  await instanceAdminClient.createInstance(instanceOptions);
await operation.promise();
console.log(`Created Instance: ${prodInstance.name}`);

PHP

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

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

use Exception;
use Google\ApiCore\ApiException;
use Google\Cloud\Bigtable\Admin\V2\Client\BigtableInstanceAdminClient;
use Google\Cloud\Bigtable\Admin\V2\Cluster;
use Google\Cloud\Bigtable\Admin\V2\CreateInstanceRequest;
use Google\Cloud\Bigtable\Admin\V2\GetInstanceRequest;
use Google\Cloud\Bigtable\Admin\V2\Instance;
use Google\Cloud\Bigtable\Admin\V2\Instance\Type as InstanceType;
use Google\Cloud\Bigtable\Admin\V2\StorageType;

/**
 * Create a production Bigtable instance
 *
 * @param string $projectId The Google Cloud project ID
 * @param string $instanceId The ID of the Bigtable instance to be generated
 * @param string $clusterId The ID of the cluster to be generated
 * @param string $locationId The Bigtable region ID where you want your instance to reside
 */
function create_production_instance(
    string $projectId,
    string $instanceId,
    string $clusterId,
    string $locationId = 'us-east1-b'
): void {
    $instanceAdminClient = new BigtableInstanceAdminClient();

    $projectName = $instanceAdminClient->projectName($projectId);
    $instanceName = $instanceAdminClient->instanceName($projectId, $instanceId);

    $serveNodes = 3;
    $storageType = StorageType::SSD;
    $production = InstanceType::PRODUCTION;
    $labels = ['prod-label' => 'prod-label'];

    $instance = new Instance();
    $instance->setDisplayName($instanceId);

    $instance->setLabels($labels);
    $instance->setType($production);

    $cluster = new Cluster();
    $cluster->setDefaultStorageType($storageType);
    $locationName = $instanceAdminClient->locationName($projectId, $locationId);
    $cluster->setLocation($locationName);
    $cluster->setServeNodes($serveNodes);
    $clusters = [
        $clusterId => $cluster
    ];
    try {
        $getInstanceRequest = (new GetInstanceRequest())
            ->setName($instanceName);
        $instanceAdminClient->getInstance($getInstanceRequest);
        printf('Instance %s already exists.' . PHP_EOL, $instanceId);
        throw new Exception(sprintf('Instance %s already exists.' . PHP_EOL, $instanceId));
    } catch (ApiException $e) {
        if ($e->getStatus() === 'NOT_FOUND') {
            printf('Creating an Instance: %s' . PHP_EOL, $instanceId);
            $createInstanceRequest = (new CreateInstanceRequest())
                ->setParent($projectName)
                ->setInstanceId($instanceId)
                ->setInstance($instance)
                ->setClusters($clusters);
            $operationResponse = $instanceAdminClient->createInstance($createInstanceRequest);
            $operationResponse->pollUntilComplete();
            if (!$operationResponse->operationSucceeded()) {
                print('Error: ' . $operationResponse->getError()->getMessage());
            } else {
                printf('Instance %s created.', $instanceId);
            }
        } else {
            throw $e;
        }
    }
}

Python

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

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

cluster = instance.cluster(
    cluster_id,
    location_id=location_id,
    serve_nodes=serve_nodes,
    default_storage_type=storage_type,
)
if not instance.exists():
    print("\nCreating an instance")
    # Create instance with given options
    operation = instance.create(clusters=[cluster])
    # Ensure the operation completes.
    operation.result(timeout=480)
    print("\nCreated instance: {}".format(instance_id))

Ruby

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

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

# instance_id      = "my-instance"
# cluster_id       = "my-cluster"
# cluster_location = "us-east1-b"
puts "Creating a PRODUCTION Instance"
job = bigtable.create_instance(
  instance_id,
  display_name: "Sample production instance",
  labels:       { "env": "production" },
  type:         :PRODUCTION # Optional as default type is :PRODUCTION
) do |clusters|
  clusters.add cluster_id, cluster_location, nodes: 3, storage_type: :SSD
end

job.wait_until_done!
instance = job.instance
puts "Created Instance: #{instance.instance_id}"

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

• איך Bigtable משתמש במכונות, באשכולות ובצמתים
• מידע על רפליקציה ב-Bigtable
• בודקים ומעדכנים את פרופיל ברירת המחדל של האפליקציה לרפליקציה, ויוצרים פרופילים בהתאמה אישית של האפליקציה לפי הצורך.
• איך משנים מכונה קיימת