Scaling

Le scaling d'un cluster est le processus consistant à ajouter ou supprimer des nœuds d'un cluster en réponse aux modifications des charges de travail ou des besoins en stockage de données. Il peut être utile de faire évoluer votre cluster Bigtable 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 é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é.

Options de scaling

Vous pouvez procéder au scaling d'un cluster Bigtable de différentes manières :

Dans la plupart des cas, si vous souhaitez un scaling automatique, vous devez utiliser la fonctionnalité d'autoscaling intégrée de Bigtable. Lorsque vous activez cette fonctionnalité, Bigtable surveille en permanence le cluster et ajuste automatiquement le nombre de nœuds en fonction de vos paramètres.

Limites

Avant d'activer l'autoscaling ou de configurer le scaling de votre cluster Bigtable, tenez compte des limitations suivantes.

Disponibilité des nœuds

Les quotas de nœuds s'appliquent si l'allocation manuelle ou l'autoscaling sont activés sur le cluster. Pour en savoir plus, consultez la section Quotas et disponibilité des nœuds.

Délai pendant le rééquilibrage des nœuds

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 des pics d'utilisation courts, l'ajout de nœuds en fonction de la charge de processeur n'améliorera pas les performances de votre cluster, car le pic d'utilisation sera probablement terminé avant que Cloud Bigtable ne rééquilibre vos données.

Pour gérer ce délai, 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 à Bigtable pour rééquilibrer vos données entre les nœuds supplémentaires avant d'augmenter la charge de travail. Sur les clusters qui utilisent l'allocation manuelle de nœuds, modifiez le nombre de nœuds. Sur les clusters qui utilisent l'autoscaling, modifiez le nombre minimal de nœuds. Une fois que votre trafic revient à la normale, rétablissez vos anciens paramètres de nœud.

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 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 Bigtable, consultez la page Concevoir votre schéma.

Définir un scaling automatisé sur Bigtable

Dans certains cas, vous pouvez écrire votre propre application pour procéder au scaling de votre cluster Bigtable. Cette section explique comment faire évoluer un cluster de manière 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.

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 Bigtable ou de Google Cloud CLI. Après avoir redimensionné votre cluster, vous pouvez surveiller ses performances à l'aide de la console Google Cloud, 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 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

Pour savoir comment installer et utiliser la bibliothèque cliente pour Bigtable, consultez la page Bibliothèques clientes Bigtable.

Pour vous authentifier auprès de Bigtable, configurez les Identifiants par défaut de l'application. Pour en savoir plus, consultez la page Configurer l'authentification pour les bibliothèques clientes. 

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

Pour savoir comment installer et utiliser la bibliothèque cliente pour Bigtable, consultez la page Bibliothèques clientes Bigtable.

Pour vous authentifier auprès de Bigtable, configurez les Identifiants par défaut de l'application. Pour en savoir plus, consultez la page Configurer l'authentification pour les bibliothèques clientes. 

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 Bigtable :

Java

Pour savoir comment installer et utiliser la bibliothèque cliente pour Bigtable, consultez la page Bibliothèques clientes Bigtable.

Pour vous authentifier auprès de Bigtable, configurez les Identifiants par défaut de l'application. Pour en savoir plus, consultez la page Configurer l'authentification pour les bibliothèques clientes. 

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

Pour savoir comment installer et utiliser la bibliothèque cliente pour Bigtable, consultez la page Bibliothèques clientes Bigtable.

Pour vous authentifier auprès de Bigtable, configurez les Identifiants par défaut de l'application. Pour en savoir plus, consultez la page Configurer l'authentification pour les bibliothèques clientes. 

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
        operation = cluster.update()
        response = operation.result(480)
        logger.info(
            "Scaled up from {} to {} nodes for {}.".format(
                current_node_count, new_node_count, response.name
            )
        )
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
        operation = cluster.update()
        response = operation.result(480)
        logger.info(
            "Scaled down from {} to {} nodes for {}.".format(
                current_node_count, new_node_count, response.name
            )
        )

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

Étapes suivantes