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

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

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

המסוף

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

    כניסה ל-Spanner

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

  3. בתפריט הניווט, בוחרים באפשרות Instance partitions (חלוקות של מופעים).

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

המסוף

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

    כניסה ל-Spanner

  2. בוחרים מופע מהרשימה.

  3. בתפריט הניווט, בוחרים באפשרות Instance partitions (חלוקות של מופעים).

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

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

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

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

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

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

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

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

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

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

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

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

המסוף

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

    כניסה לדף Instances

  2. בוחרים מופע מהרשימה.

  3. בתפריט הניווט, בוחרים באפשרות Instance partitions (חלוקות של מופעים).

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

  5. בקטע בחירת מצב התאמה, מסמנים את התיבה הקצאה ידנית.

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

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

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

gcloud

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

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

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