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

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

יצירת מחיצה של מכונה

המסוף

  1. פותחים את הדף Spanner במסוף Google Cloud .

    כניסה ל-Spanner

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

  3. בתפריט הניווט, לוחצים על Instance partitions.

  4. לוחצים על Create instance partition.

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

  6. בקטע Choose a configuration, בוחרים באפשרות Regional או Multi-region. לחלופין, אם רוצים להשוות בין המפרטים של האזורים, לוחצים על Compare region configurations.

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

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

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

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

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

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

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

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

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

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

gcloud

כדי ליצור מחיצה של מכונה, משתמשים ב-gcloud spanner instance-partitions create.

gcloud spanner instance-partitions create INSTANCE_PARTITION_ID \
  --config=INSTANCE_PARTITION_CONFIG \
  --description="INSTANCE_PARTITION_DESCRIPTION" \
  --instance=INSTANCE_ID \
  [--nodes=NODE_COUNT | --processing-units=PROCESSING_UNIT_COUNT]

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

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

לדוגמה, כדי ליצור מחיצה של מכונה europe-partition ב-eur3 עם 5 צמתים, מריצים את הפקודה הבאה:

  gcloud spanner instance-partitions create europe-partition --config=eur3 \
    --description="europe-partition" --instance=test-instance --nodes=5

שימוש בהתאמה מנוהלת לעומס (autoscaling)

אפשר להשתמש בניהול של התאמה לעומס באמצעות הפקודה gcloud spanner instance-partitions create. מידע נוסף זמין במאמר התאמה אוטומטית מנוהלת לעומס (autoscaling).

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

  gcloud 
  spanner instance-partitions create INSTANCE_PARTITION_ID \
    --config=INSTANCE_PARTITION_CONFIG \
    --description="INSTANCE_PARTITION_DESCRIPTION" \
    --instance=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

או

  gcloud spanner instance-partitions create INSTANCE_PARTITION_ID \
    --config=INSTANCE_PARTITION_CONFIG \
    --description="INSTANCE_PARTITION_DESCRIPTION" \
    --instance=INSTANCE_ID \
    --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

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

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

ספריות לקוח

C++‎

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

void CreateInstancePartition(
    google::cloud::spanner_admin::InstanceAdminClient client,
    std::string const& project_id, std::string const& instance_id,
    std::string const& instance_partition_id) {
  auto project = google::cloud::Project(project_id);
  auto in = google::cloud::spanner::Instance(project_id, instance_id);
  auto config = project.FullName() + "/instanceConfigs/nam3";

  google::spanner::admin::instance::v1::CreateInstancePartitionRequest request;
  request.set_parent(in.FullName());
  request.set_instance_partition_id(instance_partition_id);
  request.mutable_instance_partition()->set_display_name(
      "Test instance partition");
  request.mutable_instance_partition()->set_node_count(1);
  request.mutable_instance_partition()->set_config(config);

  auto instance_partition = client.CreateInstancePartition(request).get();
  if (!instance_partition) throw std::move(instance_partition).status();
  std::cout << "Created instance partition [" << instance_partition_id << "]:\n"
            << instance_partition->DebugString();
}

C#‎

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


using Google.Cloud.Spanner.Admin.Instance.V1;
using Google.Cloud.Spanner.Common.V1;
using Google.LongRunning;
using System;

public class CreateInstancePartitionSample
{
    public InstancePartition CreateInstancePartition(string projectId, string instanceId, string instancePartitionId)
    {
        // Create the InstanceAdminClient instance.
        InstanceAdminClient instanceAdminClient = InstanceAdminClient.Create();

        // Initialize request parameters.
        InstancePartition partition = new InstancePartition
        {
            DisplayName = "This is a display name.",
            NodeCount = 1,
            ConfigAsInstanceConfigName = InstanceConfigName.FromProjectInstanceConfig(projectId, "nam3"),
        };
        InstanceName instanceName = InstanceName.FromProjectInstance(projectId, instanceId);

        // Make the CreateInstancePartition request.
        Operation<InstancePartition, CreateInstancePartitionMetadata> response = instanceAdminClient.CreateInstancePartition(instanceName, partition, instancePartitionId);

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

        // Poll until the returned long-running operation is complete.
        Operation<InstancePartition, CreateInstancePartitionMetadata> completedResponse = response.PollUntilCompleted();

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

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

        return completedResponse.Result;
    }
}

המשך

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

import (
	"context"
	"fmt"
	"io"

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

// Example of creating an instance partition with Go.
// projectID is the ID of the project that the new instance partition will be in.
// instanceID is the ID of the instance that the new instance partition will be in.
// instancePartitionID is the ID of the new instance partition to be created.
func createInstancePartition(w io.Writer, projectID, instanceID, instancePartitionID string) error {
	// projectID := "my-project-id"
	// instanceID := "my-instance"
	// instancePartitionID := "my-instance-partition"
	ctx := context.Background()
	instanceAdmin, err := instance.NewInstanceAdminClient(ctx)
	if err != nil {
		return err
	}
	defer instanceAdmin.Close()

	op, err := instanceAdmin.CreateInstancePartition(ctx, &instancepb.CreateInstancePartitionRequest{
		Parent:              fmt.Sprintf("projects/%s/instances/%s", projectID, instanceID),
		InstancePartitionId: instancePartitionID,
		InstancePartition: &instancepb.InstancePartition{
			Config:          fmt.Sprintf("projects/%s/instanceConfigs/%s", projectID, "nam3"),
			DisplayName:     "my-instance-partition",
			ComputeCapacity: &instancepb.InstancePartition_NodeCount{NodeCount: 1},
		},
	})
	if err != nil {
		return fmt.Errorf("could not create instance partition %s: %w", fmt.Sprintf("projects/%s/instances/%s/instancePartitions/%s", projectID, instanceID, instancePartitionID), err)
	}
	// Wait for the instance partition creation to finish.
	i, err := op.Wait(ctx)
	if err != nil {
		return fmt.Errorf("waiting for instance partition creation to finish failed: %w", err)
	}
	// The instance partition may not be ready to serve yet.
	if i.State != instancepb.InstancePartition_READY {
		fmt.Fprintf(w, "instance partition state is not READY yet. Got state %v\n", i.State)
	}
	fmt.Fprintf(w, "Created instance partition [%s]\n", instancePartitionID)
	return nil
}

Java

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


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.CreateInstancePartitionRequest;
import com.google.spanner.admin.instance.v1.InstanceConfigName;
import com.google.spanner.admin.instance.v1.InstanceName;
import com.google.spanner.admin.instance.v1.InstancePartition;
import java.util.concurrent.ExecutionException;

class CreateInstancePartitionSample {

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

  static void createInstancePartition(
      String projectId, String instanceId, String instancePartitionId) {
    // Set instance partition configuration.
    int nodeCount = 1;
    String displayName = "Descriptive name";

    // Create an InstancePartition object that will be used to create the instance partition.
    InstancePartition instancePartition =
        InstancePartition.newBuilder()
            .setDisplayName(displayName)
            .setNodeCount(nodeCount)
            .setConfig(InstanceConfigName.of(projectId, "nam3").toString())
            .build();

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

      // Wait for the createInstancePartition operation to finish.
      InstancePartition createdInstancePartition =
          instanceAdminClient
              .createInstancePartitionAsync(
                  CreateInstancePartitionRequest.newBuilder()
                      .setParent(InstanceName.of(projectId, instanceId).toString())
                      .setInstancePartitionId(instancePartitionId)
                      .setInstancePartition(instancePartition)
                      .build())
              .get();
      System.out.printf(
          "Instance partition %s was successfully created%n", createdInstancePartition.getName());
    } catch (ExecutionException e) {
      System.out.printf(
          "Error: Creating instance partition %s failed with error message %s%n",
          instancePartition.getName(), e.getMessage());
    } catch (InterruptedException e) {
      System.out.println(
          "Error: Waiting for createInstancePartition operation to finish was interrupted");
    }
  }
}

Node.js

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

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

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

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

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

// Creates a new instance partition
try {
  console.log(
    `Creating instance partition ${instanceAdminClient.instancePartitionPath(
      projectId,
      instanceId,
      instancePartitionId,
    )}.`,
  );
  const [operation] = await instanceAdminClient.createInstancePartition({
    instancePartitionId: instancePartitionId,
    parent: instanceAdminClient.instancePath(projectId, instanceId),
    instancePartition: {
      config: instanceAdminClient.instanceConfigPath(projectId, 'nam3'),
      nodeCount: 1,
      displayName: 'Test instance partition',
    },
  });

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

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

PHP

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

use Google\Cloud\Spanner\Admin\Instance\V1\Client\InstanceAdminClient;
use Google\Cloud\Spanner\Admin\Instance\V1\CreateInstancePartitionRequest;
use Google\Cloud\Spanner\Admin\Instance\V1\InstancePartition;

/**
 * Creates an instance partition.
 * Example:
 * ```
 * create_instance_partition($projectId, $instanceId, $instancePartitionId);
 * ```
 *
 * @param string $projectId The Google Cloud project ID.
 * @param string $instanceId The Spanner instance ID.
 * @param string $instancePartitionId The instance partition ID.
 */
function create_instance_partition(string $projectId, string $instanceId, string $instancePartitionId): void
{
    $instanceAdminClient = new InstanceAdminClient();

    $instanceName = $instanceAdminClient->instanceName($projectId, $instanceId);
    $instancePartitionName = $instanceAdminClient->instancePartitionName($projectId, $instanceId, $instancePartitionId);
    $configName = $instanceAdminClient->instanceConfigName($projectId, 'nam3');

    $instancePartition = (new InstancePartition())
        ->setConfig($configName)
        ->setDisplayName('Test instance partition.')
        ->setNodeCount(1);

    $operation = $instanceAdminClient->createInstancePartition(
        (new CreateInstancePartitionRequest())
        ->setParent($instanceName)
        ->setInstancePartitionId($instancePartitionId)
        ->setInstancePartition($instancePartition)
    );

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

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

Python

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

def create_instance_partition(instance_id, instance_partition_id):
    """Creates an instance partition."""
    from google.cloud.spanner_admin_instance_v1.types import spanner_instance_admin

    spanner_client = spanner.Client()
    instance_admin_api = spanner_client.instance_admin_api

    config_name = "{}/instanceConfigs/nam3".format(spanner_client.project_name)

    operation = spanner_client.instance_admin_api.create_instance_partition(
        parent=instance_admin_api.instance_path(spanner_client.project, instance_id),
        instance_partition_id=instance_partition_id,
        instance_partition=spanner_instance_admin.InstancePartition(
            config=config_name,
            display_name="Test instance partition",
            node_count=1,
        ),
    )

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

    print("Created instance partition {}".format(instance_partition_id))

תיאור של מחיצת מכונה

gcloud

כדי לתאר מחיצה של מכונה, משתמשים בפקודה gcloud spanner instance-partitions describe.

gcloud spanner instance-partitions describe PARTITION_ID \
  --instance=INSTANCE_ID

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

  • ‫INSTANCE_PARTITION_ID: המזהה הקבוע של מחיצת המכונה.
  • ‫INSTANCE_ID: המזהה הקבוע של המכונה.

לדוגמה, כדי לתאר את מחיצת המכונה europe-partition, מריצים את הפקודה הבאה:

  gcloud spanner instance-partitions describe europe-partition
    --instance=test-instance

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

המסוף

  1. פותחים את הדף Spanner במסוף Google Cloud .

    כניסה ל-Spanner

  2. בוחרים מכונה מהרשימה.

  3. בתפריט הניווט, לוחצים על Instance partitions.

    מוצגת רשימה של מחיצות המכונה שמשויכות למכונה הזו.

gcloud

כדי להציג את המחיצות של המכונה, משתמשים בפקודה gcloud spanner instance-partitions list.

gcloud spanner instance-partitions list --instance=INSTANCE_ID

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

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

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

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

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

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

המסוף

  1. פותחים את הדף Spanner במסוף Google Cloud .

    כניסה ל-Spanner

  2. בוחרים מכונה מהרשימה.

  3. בתפריט הניווט, לוחצים על Instance partitions.

  4. ברשימת המחיצות של המכונה, בעמודה Actions לוחצים על More Actions ובוחרים באפשרות Edit.

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

    במחיצת המכונה צריך להיות לפחות צומת אחד (1,000 יחידות עיבוד).

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

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

gcloud

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

gcloud spanner instance-partitions update INSTANCE_PARTITION_ID \
  --instance=INSTANCE_ID \
  [--nodes=NODE_COUNT | --processing-units=PROCESSING_UNIT_COUNT]
  [--async]

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

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

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

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

כדי לבדוק את סטטוס הבקשה, מריצים את הפקודה gcloud spanner operations describe.

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

המגבלות הבאות חלות כשמפעילים או משנים את התכונה 'התאמה אוטומטית לעומס מנוהלת' במחיצה קיימת של מכונה:

המסוף

  1. פותחים את הדף Spanner במסוף Google Cloud .

    כניסה ל-Spanner

  2. בוחרים מכונה מהרשימה.

  3. בתפריט הניווט, לוחצים על Instance partitions.

  4. ברשימת המחיצות של המכונה, בעמודה Actions לוחצים על More Actions ובוחרים באפשרות Edit.

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

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

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

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

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

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

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

gcloud

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

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

  gcloud spanner instance-partitions update INSTANCE_PARTITION_ID \
    --instance=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

או

  gcloud spanner instance-partitions update INSTANCE_PARTITION_ID \
    --instance=INSTANCE_ID \
    --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

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

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

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

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

שינוי מחיצה של מכונה משימוש ב-autoscaler מנוהל לשינוי קנה מידה ידני

המסוף

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

    כניסה לדף Instances

  2. בוחרים מכונה מהרשימה.

  3. בתפריט הניווט, לוחצים על Instance partitions.

  4. ברשימת המחיצות של המכונה, בעמודה Actions לוחצים על More Actions ובוחרים באפשרות Edit.

  5. בקטע Choose a scaling mode, מסמנים את התיבה Manual allocation.

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

gcloud

משתמשים בפקודה gcloud spanner instance-partitions update כדי לעדכן את המחיצה של המכונה.

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

  gcloud spanner instance-partitions update INSTANCE_PARTITION_ID \
    --instance=INSTANCE_ID \
  --processing-units=PROCESSING_UNIT_COUNT

או

  gcloud spanner instance-partitions update INSTANCE_PARTITION_ID \
    --instance=INSTANCE_ID \
  --nodes=NODE_COUNT

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

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

מחיקת מחיצה של מכונה

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

המסוף

  1. פותחים את הדף Spanner במסוף Google Cloud .

    כניסה ל-Spanner

  2. בוחרים מכונה מהרשימה.

  3. בתפריט הניווט, לוחצים על Instance partitions.

  4. ברשימת המחיצות של המכונה, בעמודה Actions לוחצים על More Actions ובוחרים באפשרות Delete.

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

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

gcloud

משתמשים בפקודה gcloud spanner instance-partitions delete.

gcloud spanner instance-partitions delete INSTANCE_PARTITION_ID
  --instance=INSTANCE_ID

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