Définir un scaling automatisé sur Cloud Bigtable

Dans certains cas, il peut être utile de faire évoluer votre cluster Cloud Bigtable de façon automatisée en fonction de métriques, telles que l'utilisation du processeur du cluster. Par exemple, si votre cluster est soumis à des charges importantes et que son utilisation du processeur est extrêmement élevée, vous pouvez ajouter des nœuds au cluster jusqu'à ce que son utilisation diminue. Vous pouvez également économiser de l'argent en supprimant les nœuds du cluster lorsqu'il est peu utilisé.

Cette page explique comment faire évoluer votre cluster Cloud Bigtable de façon automatisée et fournit un exemple de code que vous pouvez utiliser comme point de départ. Elle présente également quelques restrictions à prendre en compte avant de configurer le scaling de façon automatisée.

Définir un scaling automatisé sur Cloud Bigtable

Cloud Bigtable propose une multitude de métriques via l'API Cloud Monitoring. Vous pouvez surveiller celles de votre cluster de façon automatisée, puis ajouter ou supprimer des nœuds en fonction des métriques existantes à l'aide d'une des bibliothèques clientes Cloud Bigtable ou de l'outil de ligne de commande gcloud. Après avoir redimensionné votre cluster, vous pouvez surveiller ses performances à l'aide de Cloud Console, d'un tableau de bord personnalisé Cloud Monitoring, ou de façon automatisée.

Métriques de l'API Monitoring

L'API Monitoring fournit plusieurs métriques que vous pouvez utiliser pour surveiller l'état actuel de votre cluster. Voici quelques-unes des métriques les plus utiles pour le scaling automatisé :

  • bigtable.googleapis.com/cluster/cpu_load : charge du processeur du cluster
  • bigtable.googleapis.com/cluster/node_count : nombre de nœuds du cluster
  • bigtable.googleapis.com/cluster/storage_utilization : stockage utilisé par rapport à la capacité totale disponible
  • bigtable.googleapis.com/server/latencies : répartition des latences sur les requêtes serveur pour une table

Exemple de code

Pour développer votre propre outil de scaling automatisé, vous pouvez utiliser l'un des exemples d'outils suivants :

Les exemples d'outils ajoutent des nœuds à un cluster Cloud Bigtable lorsque la charge de son processeur dépasse une valeur spécifiée. De même, ils en suppriment lorsque la charge du processeur du cluster est inférieure à une valeur spécifiée. Pour exécuter les exemples d'outils, suivez les instructions de chaque exemple sur GitHub.

Les exemples d'outils utilisent le code suivant pour collecter des informations sur la charge du processeur du 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

En fonction de la charge du processeur, les exemples d'outils redimensionnent le cluster à l'aide de la bibliothèque cliente Cloud Bigtable :

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

Après avoir redimensionné le cluster, vous pouvez surveiller l'évolution de ses performances au fil du temps à l'aide de Cloud Console ou d'un tableau de bord personnalisé Cloud Monitoring.

Limites

Avant de configurer le scaling de votre cluster Cloud Bigtable de façon automatisée, prenez en compte les restrictions suivantes.

Temps d'attente avant l'amélioration des performances

Une fois que vous avez ajouté des nœuds à un cluster, un délai de 20 minutes peut s'écouler avant que vous constatiez une amélioration significative des performances du cluster. Par conséquent, si votre charge de travail implique de brèves utilisations intensives, l'ajout de nœuds n'améliore pas les performances de votre cluster en fonction de la charge du processeur. L'utilisation intensive cesse lorsque Cloud Bigtable rééquilibre vos données.

Pour résoudre ce problème, vous pouvez ajouter des nœuds à votre cluster, de façon automatisée ou via Google Cloud Console, avant d'augmenter la charge du cluster. Cette approche donne suffisamment de temps à Cloud Bigtable pour rééquilibrer vos données entre les nœuds supplémentaires.

Augmentation de la latence provoquée par une réduction trop rapide de la capacité

Lorsque vous réduisez le nombre de nœuds d'un cluster, ne réduisez pas la taille du cluster de plus de 10 % sur une période de 10 minutes. Une réduction trop rapide de la capacité peut entraîner des problèmes de performances, tels qu'une latence accrue, si les nœuds restants du cluster deviennent temporairement surchargés.

Problèmes de conception de schémas

Si vous rencontrez des problèmes lors de la conception du schéma de votre table, l'ajout de nœuds à votre cluster Cloud Bigtable peut ne pas améliorer les performances. Par exemple, si vous avez un grand nombre de lectures ou d'écritures sur une seule ligne de votre table, toutes ces opérations sont dirigées vers le même nœud de votre cluster. Par conséquent, l'ajout de nœuds n'améliore pas les performances. En revanche, si les lectures et les écritures sont réparties uniformément sur les lignes de votre table, l'ajout de nœuds améliore généralement les performances.

Pour en savoir plus sur la conception d'un schéma permettant de faire évoluer efficacement Cloud Bigtable, consultez la page Concevoir votre schéma.

Étapes suivantes