Cloud Bigtable programmatisch skalieren

In einigen Fällen kann es sinnvoll sein, Ihren Cloud Bigtable-Cluster programmatisch anhand von Messwerten wie zum Beispiel der CPU-Nutzung des Clusters zu skalieren. Wenn Ihr Cluster beispielsweise stark ausgelastet und die CPU-Nutzung extrem hoch ist, können Sie weitere Knoten in den Cluster aufnehmen, bis dessen CPU-Nutzung sinkt. Auf der anderen Seite können Sie auch Geld sparen, indem Sie Knoten aus dem Cluster entfernen, wenn er nicht so stark ausgelastet ist.

Auf dieser Seite wird erklärt, wie Sie Ihren Cloud Bigtable-Cluster programmatisch skalieren können. Zum Einstieg dafür finden Sie hier ein Codebeispiel. Außerdem werden einige Einschränkungen genannt, die Sie beachten sollten, bevor Sie die programmatische Skalierung einrichten.

So wird Cloud Bigtable programmatisch skaliert

Cloud Bigtable bietet eine Vielzahl von Messwerten über die Cloud Monitoring API. Sie können diese Messwerte für Ihren Cluster programmatisch beobachten und anschließend eine der Cloud Bigtable-Clientbibliotheken oder das gcloud-Befehlszeilentool verwenden, um Knoten anhand von aktuellen Messwerten hinzuzufügen oder zu entfernen. Nachdem Sie die Größe des Clusters geändert haben, können Sie über die Cloud Console über ein benutzerdefiniertes Cloud Monitoring-Dashboard oder programmatisch die Leistung des Clusters beobachten.

API-Messwerte beobachten

Die Monitoring API stellt eine Vielzahl von Messwerten zur Verfügung, mit denen Sie den aktuellen Zustand Ihres Clusters überwachen können. Zu den nützlichsten Messwerten für die programmatische Skalierung gehören:

  • bigtable.googleapis.com/cluster/cpu_load: Die CPU-Auslastung des Clusters.
  • bigtable.googleapis.com/cluster/node_count: Die Anzahl der Knoten im Cluster.
  • bigtable.googleapis.com/cluster/storage_utilization: Der Speicherplatz, der als Teil der Gesamtspeicherkapazität verwendet wird.
  • bigtable.googleapis.com/server/latencies: Die Verteilung der Serveranfragelatenzen für eine Tabelle.

Beispielcode

Als Ausgangspunkt für Ihr eigenes programmatisches Skalierungstool können Sie eines der folgenden Beispieltools verwenden:

Diese Beispieltools nehmen weitere Knoten in einen Cloud Bigtable-Cluster auf, wenn dessen CPU-Auslastung über einem bestimmten Wert liegt. Ebenso entfernen die Beispieltools Knoten aus einem Cloud Bigtable-Cluster, wenn seine CPU-Auslastung unter einen bestimmten Wert sinkt. Um die Beispieltools auszuführen, folgen Sie der Anleitung für das jeweilige Beispiel auf GitHub.

Die Beispieltools verwenden folgenden Code, um Informationen über die CPU-Auslastung des Clusters zu erfassen:

Java

Timestamp now = timeXMinutesAgo(0);
Timestamp fiveMinutesAgo = timeXMinutesAgo(5);
TimeInterval interval =
    TimeInterval.newBuilder().setStartTime(fiveMinutesAgo).setEndTime(now).build();
String filter = "metric.type=\"" + CPU_METRIC + "\"";
ListTimeSeriesPagedResponse response =
    metricServiceClient.listTimeSeries(projectName, filter, interval, TimeSeriesView.FULL);
return response.getPage().getValues().iterator().next().getPointsList().get(0);

Python

client = monitoring_v3.MetricServiceClient()
cpu_query = query.Query(client,
                        project=PROJECT,
                        metric_type='bigtable.googleapis.com/'
                                    'cluster/cpu_load',
                        minutes=5)
cpu_query = cpu_query.select_resources(instance=bigtable_instance, cluster=bigtable_cluster)
cpu = next(cpu_query.iter())
return cpu.points[0].value.double_value

Die Beispieltools setzen die Cloud Bigtable-Clientbibliothek ein, um die Größe des Clusters auf der Grundlage der CPU-Auslastung zu ändern:

Java

double latestValue = getLatestValue().getValue().getDoubleValue();
if (latestValue < CPU_PERCENT_TO_DOWNSCALE) {
  int clusterSize = clusterUtility.getClusterNodeCount(clusterId, zoneId);
  if (clusterSize > MIN_NODE_COUNT) {
    clusterUtility.setClusterSize(clusterId, zoneId,
      Math.max(clusterSize - SIZE_CHANGE_STEP, MIN_NODE_COUNT));
  }
} else if (latestValue > CPU_PERCENT_TO_UPSCALE) {
  int clusterSize = clusterUtility.getClusterNodeCount(clusterId, zoneId);
  if (clusterSize <= MAX_NODE_COUNT) {
    clusterUtility.setClusterSize(clusterId, zoneId,
      Math.min(clusterSize + SIZE_CHANGE_STEP, MAX_NODE_COUNT));
  }
}

Python

bigtable_client = bigtable.Client(admin=True)
instance = bigtable_client.instance(bigtable_instance)
instance.reload()

if instance.type_ == enums.Instance.Type.DEVELOPMENT:
    raise ValueError("Development instances cannot be scaled.")

cluster = instance.cluster(bigtable_cluster)
cluster.reload()

current_node_count = cluster.serve_nodes

if scale_up:
    if current_node_count < max_node_count:
        new_node_count = min(
            current_node_count + size_change_step, max_node_count)
        cluster.serve_nodes = new_node_count
        cluster.update()
        logger.info('Scaled up from {} to {} nodes.'.format(
            current_node_count, new_node_count))
else:
    if current_node_count > min_node_count:
        new_node_count = max(
            current_node_count - size_change_step, min_node_count)
        cluster.serve_nodes = new_node_count
        cluster.update()
        logger.info('Scaled down from {} to {} nodes.'.format(
            current_node_count, new_node_count))

Nachdem Sie die Clustergröße geändert haben, können Sie über die Cloud Console oder über ein benutzerdefiniertes Cloud Monitoring-Dashboard beobachten, wie sich die Clusterleistung im Lauf der Zeit ändert.

Beschränkungen

Bevor Sie die programmatische Skalierung für Ihren Cloud Bigtable-Cluster einrichten, sollten Sie die folgenden Einschränkungen bedenken.

Verzögerung bei Leistungsverbesserungen

Nachdem Sie Knoten einem Cluster hinzugefügt haben, kann es bis zu 20 Minuten unter Last dauern, bevor Sie eine signifikante Verbesserung der Leistung des Clusters feststellen. Daher wird das Hinzufügen von Knoten zu Ihrem Cluster aufgrund der CPU-Last keine Leistungsverbesserung bringen, wenn Ihre Arbeitslast mit kurzen Schüben hoher Aktivität verbunden ist. Sobald Cloud Bigtable so weit ist und die Daten neu ausbalanciert hat, ist der kurze Aktivitätsschub bereits wieder vorüber.

Zur Behebung dieses Problems können Sie Ihrem Cluster entweder programmatisch oder über die Google Cloud Console Knoten hinzufügen, bevor Sie die Auslastung des Clusters erhöhen. Diese Vorgehensweise verschafft Cloud Bigtable Zeit, die Daten über die zusätzlichen Knoten neu auszubalancieren.

Latenzerhöhungen durch zu schnelles Herunterskalieren

Wenn Sie die Anzahl der Knoten in einem Cluster verringern, um sie herunterzuskalieren, versuchen Sie, die Clustergröße in einem Zeitraum von 10 Minuten nicht um mehr als 10 % zu reduzieren. Wenn Sie zu schnell herunterskalieren, können Leistungsprobleme auftreten, z. B. eine höhere Latenz, wenn die verbleibenden Knoten im Cluster vorübergehend überlastet werden.

Probleme beim Schemadesign

Wenn das Schemadesign Ihrer Tabelle problematisch ist, führen weitere Knoten in Ihrem Cloud Bigtable-Cluster möglicherweise nicht zu besserer Leistung. Wenn sich beispielsweise eine große Anzahl von Lese- oder Schreibzugriffen auf eine einzelne Zeile Ihrer Tabelle richten, betreffen alle Lese- oder Schreibzugriffe denselben Knoten im Cluster. Sind die Lese- und Schreibzugriffe hingegen gleichmäßig über die Zeilen der Tabelle verteilt, führen mehr Knoten im Allgemeinen zu besserer Leistung.

Unter Schema entwerfen finden Sie Details dazu, wie Sie ein Schema entwerfen, mit dem Cloud Bigtable effektiv skalieren kann.

Weitere Informationen