Ajusta la escala de Cloud Bigtable de manera programática

En algunos casos, puede ser útil escalar tu clúster de Cloud Bigtable de manera programática según métricas como el uso de CPU del clúster. Por ejemplo, si tu clúster tiene una carga pesada y su uso de CPU es extremadamente alto, puedes agregar nodos al clúster hasta que el uso de CPU disminuya. Además, para ahorrar dinero, puedes quitar nodos del clúster cuando no se use con cargas pesadas.

En esta página, se explica cómo escalar tu clúster de Cloud Bigtable de manera programática, y se proporciona un código de muestra que puedes usar como punto de partida. También se describen algunos límites que debes tener en cuenta antes de configurar el escalamiento programático.

Escalar Cloud Bigtable de manera programática

Cloud Bigtable expone una variedad de métricas a través de la API de Cloud Monitoring. Puedes supervisar de manera programática estas métricas para el clúster y, luego, usar una de las bibliotecas cliente de Cloud Bigtable o la herramienta de línea de comandos de gcloud para agregar o quitar nodos según las métricas actuales. Después de cambiar el tamaño del clúster, puedes supervisar su rendimiento a través de Cloud Console, un panel personalizado de Cloud Monitoring o de manera programática.

Métricas de la API de Monitoring

La API de Supervisión ofrece una variedad de métricas que puedes usar para supervisar el estado actual de tu clúster. Algunas de las métricas más útiles para el escalamiento programático incluyen las siguientes:

  • bigtable.googleapis.com/cluster/cpu_load: La carga de CPU del clúster.
  • bigtable.googleapis.com/cluster/node_count: La cantidad de nodos del clúster.
  • bigtable.googleapis.com/cluster/storage_utilization: El almacenamiento se usa como una fracción de la capacidad de almacenamiento total.
  • bigtable.googleapis.com/server/latencies: La distribución de las latencias de solicitud del servidor para una tabla.

Código de muestra

Puedes usar una de las siguientes herramientas de muestra como punto de partida para tu herramienta de escalamiento programático:

Estas herramientas de muestra agregan nodos al clúster de Cloud Bigtable cuando su carga de CPU supera un valor específico. Del mismo modo, las herramientas de muestra quitan todos los nodos de un clúster de Cloud Bigtable cuando su carga de CPU es inferior a un valor especificado. Para ejecutar las herramientas de muestra, sigue las instrucciones de cada una en GitHub.

Las herramientas de muestra usan el siguiente código para recopilar información sobre la carga de CPU en el clúster:

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 = next(cpu_query.iter())
return cpu.points[0].value.double_value

Según la carga de CPU, las herramientas de muestra usan la biblioteca cliente de Cloud Bigtable para modificar el tamaño del clúster:

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()
        print('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()
        print('Scaled down from {} to {} nodes.'.format(
            current_node_count, new_node_count))

Después de cambiar el tamaño del clúster, puedes usar Cloud Console o un panel personalizado de Cloud Monitoring para supervisar cómo cambia el rendimiento con el tiempo.

Limitaciones

Antes de configurar el escalamiento programático o tu clúster de Cloud Bigtable, ten en cuenta las siguientes limitaciones.

Retraso en las mejoras de rendimiento

Después de agregar nodos a un clúster, pueden pasar hasta 20 minutos con carga para que veas una mejora notoria en el rendimiento. Como resultado, si tu carga de trabajo genera picos breves de actividad alta, agregar nodos a tu clúster en función de la carga de CPU no mejorará el rendimiento, ya que, para cuando Cloud Bigtable haya rebalanceado los datos, el pico de actividad ya habrá terminado.

Para solucionar este problema, puedes agregar nodos a tu clúster, ya sea de manera programática o a través de Google Cloud Console, antes de aumentar la carga del clúster. Este enfoque permite que Cloud Bigtable tenga tiempo de rebalancear tus datos entre los nodos adicionales.

Problemas de diseño de esquemas

Si hay problemas con el diseño del esquema de tu tabla, es posible que agregar nodos a tu clúster de Cloud Bigtable no ayude a mejorar el rendimiento. Por ejemplo, si tienes una gran cantidad de lecturas o escrituras en una sola fila de tu tabla, todas estas irán al mismo nodo del clúster; por lo tanto, agregar nodos no mejorará el rendimiento. Por el contrario, si estas están distribuidas de manera uniforme entre las filas de tu tabla, por lo general, agregar nodos mejorará el rendimiento.

Consulta Diseña tu esquema a fin de obtener detalles sobre cómo diseñar un esquema que habilite a Cloud Bigtable para escalar de forma efectiva.

Próximos pasos