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

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

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

המסוף

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

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

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

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

    • התאמה אוטומטית לעומס כדי לאפשר ל-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

שימוש בהתאמה אוטומטית לעומס מנוהלת

אפשר להשתמש בהתאמה אוטומטית לעומס מנוהלת באמצעות הפקודה 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;
    }
}

Go

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

    כניסה ל-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. במסוף Google Cloud , פותחים את הדף Spanner.

    כניסה ל-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. במסוף Google Cloud , פותחים את הדף Spanner.

    כניסה ל-Spanner

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

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

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

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

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

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

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

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

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

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

gcloud

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

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

  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. במסוף Google Cloud , פותחים את הדף Spanner.

    כניסה ל-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

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