Escalonamento programático do Cloud Bigtable

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

No Cloud Bigtable, estão expostas várias métricas por meio da API Monitoring do Stackdriver. É possível monitorá-las de maneira programática para o cluster. Use uma das bibliotecas de cliente do Cloud Bigtable ou a ferramenta de linha de comando gcloud para adicionar ou remover os nodes com base nas métricas atuais. Depois de redimensionar o cluster, é possível monitorar o desempenho por meio do Console do GCP usando um painel personalizado do Stackdriver Monitoring ou de maneira programática.

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: a carga da CPU do cluster.
  • bigtable.googleapis.com/cluster/node_count: o número de nodes no cluster.
  • bigtable.googleapis.com/cluster/storage_utilization: o 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, você pode usar 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)
time_series = list(cpu_query)
recent_time_series = time_series[0]
return recent_time_series.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()

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

Depois que o cluster for redimensionado, use o Console do GCP ou um painel personalizado do Stackdriver Monitoring para monitorar alterações no desempenho ao longo do tempo.

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 nodes 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 acabará.

Para resolver esse problema, adicione nodes ao cluster por meio de programação ou do Console do Google Cloud Platform, antes de aumentar a carga no cluster,. Essa abordagem dá tempo ao Cloud Bigtable para reequilibrar os dados por meio dos nodes extras.

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 nodes geralmente melhorará o desempenho.

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

Próximas etapas

Esta página foi útil? Conte sua opinião sobre:

Enviar comentários sobre…

Documentação do Cloud Bigtable