Como escalonar o Cloud Bigtable de forma programática

Em alguns casos, pode ser útil escalonar de maneira programática o cluster do Cloud Bigtable, com base em métricas como o uso da CPU do cluster. Por exemplo, se o cluster estiver com uma grande carga e o uso da CPU for extremamente alto, adicione nodes ao cluster até o uso da CPU cair. Para economizar dinheiro, remova os nodes do cluster quando ele não estiver sendo muito usado.

Nesta página, explicamos como fazer o escalonamento do cluster do Cloud Bigtable de maneira programática e fornecemos um exemplo de código que pode ser usado como ponto de partida. Descrevemos também algumas limitações de que você precisa saber antes de configurar o escalonamento programático.

Como fazer o escalonamento do Cloud Bigtable de maneira programática

O Cloud Bigtable expõe uma variedade de métricas por meio da API Cloud Monitoring. É possível monitorar essas métricas programaticamente para seu cluster e usar uma das bibliotecas de cliente do Cloud Bigtable ou a ferramenta de linha de comando gcloud para adicionar ou remover nós com base nas métricas atuais. Depois de redimensionar o cluster, é possível monitorar o desempenho dele por meio do Console do Cloud, por meio de um painel personalizado do Cloud Monitoring ou programaticamente.

Métricas da API Monitoring

A Monitoring API oferece várias métricas que podem ser usadas para monitorar o estado atual do cluster. Algumas das métricas mais úteis para o escalonamento programático incluem:

  • bigtable.googleapis.com/cluster/cpu_load: carga da CPU do cluster.
  • bigtable.googleapis.com/cluster/node_count: número de nós no cluster.
  • bigtable.googleapis.com/cluster/storage_utilization: armazenamento usado como uma fração da capacidade total de armazenamento.
  • bigtable.googleapis.com/server/latencies: a distribuição das latências de solicitação do servidor para uma tabela.

Exemplo de código

Como ponto de partida para sua própria ferramenta de escalonamento programático, use uma das seguintes ferramentas de exemplo:

Quando a carga de CPU está acima do valor especificado, as ferramentas de amostra são usadas para adicionar nodes a um cluster do Bigtable. De maneira similar, as ferramentas de amostra são usadas para remover nodes de um cluster do Cloud Bigtable quando a carga de CPU está abaixo do valor especificado. Para executar as ferramentas de amostra, siga as respectivas instruções no GitHub.

O seguinte código é usado nas ferramentas de amostra para coletar informações sobre a carga da CPU no cluster:

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

Dependendo da carga da CPU, a biblioteca de cliente do Cloud Bigtable é usada nas ferramentas de amostra para redimensionar o cluster:

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))

Depois que o cluster for redimensionado, será possível usar o Console do Cloud ou um painel personalizado do Cloud Monitoring para monitorar as alterações no desempenho.

Limitações

Antes de configurar o escalonamento programático do cluster do Cloud Bigtable, verifique as limitações a seguir.

Atraso nas melhorias de desempenho

Após adicionar nodes ao cluster, é necessário esperar até 20 minutos sob carga para ver uma melhoria significativa no desempenho do cluster. Se a carga de trabalho envolver breves bursts de alta atividade, a adição de nós ao cluster com base na carga da CPU não melhorará o desempenho. Quando o Cloud Bigtable reequilibrar os dados, o breve burst da atividade terminará.

Para resolver esse problema, adicione nós ao cluster, de maneira programática ou por meio do Console do Google Cloud, antes de aumentar a carga no cluster. Essa abordagem dá ao Cloud Bigtable tempo para reequilibrar os dados pelos nós extras.

Aumentos de latência devido a uma redução muito rápida

Ao diminuir o número de nós em um cluster para realizar uma redução, tente não reduzir o tamanho do cluster em mais de 10% em um período de 10 minutos. A redução muito rápida pode causar problemas de desempenho, como o aumento de latência, se os outros nós do cluster ficarem temporariamente sobrecarregados.

Problemas de design do esquema

Se houver problemas com o design do esquema para a tabela, adicionar nodes ao cluster do Cloud Bigtable pode não melhorar o desempenho. Por exemplo, se houver um grande número de leituras ou gravações em uma única linha da tabela, todas as leituras ou gravações irão para o mesmo node do cluster. A adição de nodes não melhorará o desempenho. Em contrapartida, se as leituras e as gravações estiverem distribuídas uniformemente entre as linhas da tabela, a adição de nós melhorará o desempenho em geral.

Para detalhes sobre como projetar um esquema que permita o escalonamento eficaz do Cloud Bigtable, consulte Como projetar seu esquema.

A seguir