Statistiques de fractionnement

Ce document explique comment détecter et déboguer les points chauds dans votre base de données. Vous pouvez accéder aux statistiques sur les points chauds dans les fractionnements avec GoogleSQL et PostgreSQL.

Spanner stocke vos données sous forme d'espace clé contigu, ordonné par les clés primaires de vos tables et index. Une division est une plage de lignes provenant d'un ensemble de tables ou d'un index. Le début de la division est appelé début de la division. La limite de fractionnement définit la fin du fractionnement. La fraction inclut le début de la fraction, mais pas la limite de la fraction.

Dans Spanner, les hotspots sont des situations où trop de requêtes sont envoyées au même serveur, ce qui sature les ressources du serveur et peut entraîner des latences élevées. Les divisions concernées par les points chauds sont appelées divisions actives ou tièdes.

La statistique de point chaud d'une division (identifiée dans le système par CPU_USAGE_SCORE) est une mesure de la charge sur une division limitée par les ressources disponibles sur le serveur. Cette mesure est exprimée en pourcentage. Si plus de 50 % de la charge d'une division est limitée par les ressources disponibles, la division est considérée comme "chaude". Si 100 % de la charge sur une division est limitée, la division est considérée comme active. Ces fractionnements actifs peuvent également affecter la latence des requêtes qu'ils traitent.

La CPU_USAGE_SCORE d'un fractionnement peut rester constante ou varier au fil du temps en fonction de la charge de travail accédant au fractionnement et des modifications apportées aux limites du fractionnement.

En fonction des contraintes de ressources de partitionnement chaud et tiède, Spanner peut utiliser le partitionnement basé sur la charge pour répartir uniformément la charge dans l'espace de clés. Les splits "chaud" et "très chaud" peuvent être déplacés sur les serveurs de l'instance pour équilibrer la charge. Spanner effectue une répartition basée sur la charge en arrière-plan, ce qui minimise l'impact sur la latence. Toutefois, Spanner peut ne pas être en mesure d'équilibrer la charge, même après plusieurs tentatives de fractionnement, en raison d'antimodèles dans l'application. La colonne UNSPLITTABLE_REASONS dans les vues des statistiques fournit des raisons spécifiques pour lesquelles une division chaude ou tiède n'a pas pu être fractionnée davantage. Par conséquent, les fractionnements persistants chauds ou tièdes qui durent au moins 10 minutes peuvent nécessiter un dépannage plus approfondi et des modifications potentielles de l'application, en particulier lorsque des UNSPLITTABLE_REASONS sont présents.

Les statistiques sur les divisions actives de Spanner vous aident à identifier les divisions où se produisent des hotspots et à comprendre pourquoi ils peuvent persister. Ces statistiques, combinées aux codes UNSPLITTABLE_REASONS, peuvent vous aider à diagnostiquer les actions à entreprendre pour résoudre les points chauds. Vous pouvez ensuite apporter les modifications nécessaires à votre application ou à votre schéma.

Accéder aux statistiques sur les partages rapides

Spanner fournit les statistiques de fractionnement à chaud dans le schéma SPANNER_SYS. Les données SPANNER_SYS sont disponibles via les interfaces GoogleSQL et PostgreSQL. Vous pouvez accéder à ces données de différentes manières :

Page Spanner Studio d'une base de données dans la console Google Cloud .
La commande gcloud spanner databases execute-sql
La méthode executeSql ou executeStreamingSql.

Les méthodes de lecture unique suivantes fournies par Spanner ne sont pas compatibles avec SPANNER_SYS :

effectuer une lecture forte à partir d'une ou de plusieurs lignes d'une table ;
effectuer une lecture non actualisée à partir d'une ou de plusieurs lignes d'une table ;
lire à partir d'une ou de plusieurs lignes d'un index secondaire.

Statistiques sur les divisions les plus rapides

Vous pouvez utiliser les vues suivantes pour suivre les splits les plus populaires :

SPANNER_SYS.SPLIT_STATS_TOP_MINUTE : affiche les splits les plus populaires pendant des intervalles d'une minute.
SPANNER_SYS.SPLIT_STATS_TOP_10MINUTE : affiche les fractionnements qui sont populaires à un moment donné d'un intervalle de 10 minutes.
SPANNER_SYS.SPLIT_STATS_TOP_HOUR : affiche les fractionnements qui sont populaires à un moment donné d'un intervalle d'une heure.

Ces vues présentent les propriétés suivantes :

Chaque vue contient les données correspondant à des intervalles de temps sans chevauchement de la durée spécifiée par le nom de la vue.
Les intervalles sont définis selon l'heure réelle :
- Les intervalles d'une minute se terminent toutes les minutes.
- Les intervalles de 10 minutes se terminent à la 10e minute de l'heure, par exemple à 11:10:00 et 11:20:00.
- Les intervalles d'une heure se terminent toutes les heures.
Après chaque intervalle, Spanner collecte les données de tous les serveurs, puis les met à disposition dans les vues SPANNER_SYS peu de temps après. Par exemple, à 11:59:30, les intervalles les plus récents disponibles pour les requêtes SQL sont les suivants :
- 1 minute : de 11:58:00 à 11:58:59
- 10 minutes : de 11:40:00 à 11:49:59
- 1 heure : 10:00:00 – 10:59:59
Spanner regroupe les statistiques par fractionnement.
Chaque ligne contient des statistiques, y compris le pourcentage CPU_USAGE_SCORE qui indique le degré de "chaleur" d'une division, pour chaque division pour laquelle Spanner enregistre des statistiques pendant l'intervalle spécifié.
La vue SPANNER_SYS.SPLIT_STATS_TOP_MINUTE fournit des statistiques détaillées par minute. Utilisez cette vue pour déboguer en détail les événements récents.
Les vues SPANNER_SYS.SPLIT_STATS_TOP_10MINUTE et SPANNER_SYS.SPLIT_STATS_TOP_HOUR fournissent une vue agrégée à des intervalles de 10 minutes et d'une heure, respectivement. Utilisez ces vues pour analyser les tendances ou examiner les problèmes survenus au cours des derniers jours ou des dernières semaines. Pour en savoir plus sur l'agrégation, consultez Afficher l'agrégation des événements.
Si Spanner ne parvient pas à stocker toutes les divisions actives pendant l'intervalle, le système donne la priorité aux divisions ayant le pourcentage CPU_USAGE_SCORE le plus élevé durant l'intervalle spécifié. Si aucun fractionnement n'est renvoyé, cela indique l'absence de fractionnements actifs.

Conservation des données

La quantité maximale de données que Spanner conserve pour chaque vue, à tout moment, est la suivante :

SPANNER_SYS.SPLIT_STATS_TOP_MINUTE : intervalles couvrant les 24 heures précédentes.
SPANNER_SYS.SPLIT_STATS_TOP_10MINUTE : intervalles couvrant les quatre derniers jours.
SPANNER_SYS.SPLIT_STATS_TOP_HOUR : intervalles couvrant les 30 derniers jours.

Vous ne pouvez pas augmenter ni diminuer ces périodes de conservation, et vous ne pouvez pas empêcher Spanner de collecter des statistiques sur les fractionnements à chaud.

Pour supprimer les données statistiques, vous devez supprimer la base de données suivie ou attendre que les données statistiques ne soient plus conservées.
Pour conserver les données statistiques pendant de plus longues périodes, copiez régulièrement les données des vues statistiques fractionnées "chaudes".

Afficher le schéma

Le tableau suivant présente le schéma des statistiques de fractionnement à chaud :

Nom de la colonne	Type	Description
`INTERVAL_END`	`TIMESTAMP`	Fin de l'intervalle de temps pendant lequel la division était à l'état tiède ou chaud.
`SPLIT_START`	`STRING`	Clé de début de la plage de lignes dans la division. Le début de la division peut aussi être <begin>, ce qui indique le début de l'espace de clés.
`SPLIT_LIMIT`	`STRING`	Clé de limite pour la plage de lignes dans la division. La clé de limite peut aussi être <end>, ce qui indique la fin de l'espace de clés.
`CPU_USAGE_SCORE`	`INT64`	Pourcentage `CPU_USAGE_SCORE` des répartitions. Un pourcentage de `CPU_USAGE_SCORE` de 50 % indique la présence de divisions chaudes ou très chaudes.
`AFFECTED_TABLES`	`STRING ARRAY`	Il s'agit des tables dont les lignes peuvent être dans la division.
`UNSPLITTABLE_REASONS`	`STRING ARRAY`	Identifie le type de points chauds présents que le fractionnement basé sur la charge ne peut pas atténuer, souvent en raison d'anti-modèles. La présence d'un motif indique qu'une intervention de l'utilisateur est probablement nécessaire, par exemple pour ajuster le schéma ou la charge de travail. Un tableau vide signifie qu'aucune condition non fractionnable n'a été détectée au cours de cet intervalle ou que la charge élevée a été trop éphémère pour que Spanner puisse déterminer si elle était non fractionnable. Pour en savoir plus, consultez les types `UNSPLITTABLE_REASONS`.

Clés de début et de limite de fractionnement

Une division est une plage de lignes contiguës d'une base de données. Elle est définie par ses clés de début et de limite. Une division peut être une seule ligne, une plage de lignes étroite ou une plage de lignes large, et elle peut inclure plusieurs tables ou index.

Les colonnes SPLIT_START et SPLIT_LIMIT identifient les clés primaires d'une division chaude ou tiède.

Exemple de schéma

Le schéma suivant est un exemple de tableau pour les thèmes abordés sur cette page.

GoogleSQL

CREATE TABLE Users (
  UserId INT64 NOT NULL,
  FirstName STRING(MAX),
  LastName STRING(MAX),
) PRIMARY KEY(UserId);

CREATE INDEX UsersByFirstName ON Users(FirstName DESC);

CREATE TABLE Threads (
  UserId INT64 NOT NULL,
  ThreadId INT64 NOT NULL,
  Starred BOOL,
) PRIMARY KEY(UserId, ThreadId),
  INTERLEAVE IN PARENT Users ON DELETE CASCADE;

CREATE TABLE Messages (
  UserId INT64 NOT NULL,
  ThreadId INT64 NOT NULL,
  MessageId INT64 NOT NULL,
  Subject STRING(MAX),
  Body STRING(MAX),
) PRIMARY KEY(UserId, ThreadId, MessageId),
  INTERLEAVE IN PARENT Threads ON DELETE CASCADE;

CREATE INDEX MessagesIdx ON Messages(UserId, ThreadId, Subject),
INTERLEAVE IN Threads;

PostgreSQL

CREATE TABLE users
(
   userid    BIGINT NOT NULL PRIMARY KEY,-- INT64 to BIGINT
   firstname VARCHAR(max),-- STRING(MAX) to VARCHAR(MAX)
   lastname  VARCHAR(max)
);

CREATE INDEX usersbyfirstname
  ON users(firstname DESC);

CREATE TABLE threads
  (
    userid   BIGINT NOT NULL,
    threadid BIGINT NOT NULL,
    starred  BOOLEAN, -- BOOL to BOOLEAN
    PRIMARY KEY (userid, threadid),
    CONSTRAINT fk_threads_user FOREIGN KEY (userid) REFERENCES users(userid) ON
    DELETE CASCADE -- Interleave to Foreign Key constraint
  );

CREATE TABLE messages
  (
    userid    BIGINT NOT NULL,
    threadid  BIGINT NOT NULL,
    messageid BIGINT NOT NULL PRIMARY KEY,
    subject   VARCHAR(max),
    body      VARCHAR(max),
    CONSTRAINT fk_messages_thread FOREIGN KEY (userid, threadid) REFERENCES
    threads(userid, threadid) ON DELETE CASCADE
  -- Interleave to Foreign Key constraint
  );

CREATE INDEX messagesidx ON messages(userid, threadid, subject), REFERENCES
threads(userid, threadid);

Imaginez que votre espace de clés se présente comme suit :

CLÉ PRIMAIRE
`<begin>`
`Users()`
`Threads()`
`Users(2)`
`Users(3)`
`Threads(3)`
`Threads(3,"a")`
`Messages(3,"a",1)`
`Messages(3,"a",2)`
`Threads(3, "aa")`
`Users(9)`
`Users(10)`
`Threads(10)`
`UsersByFirstName("abc")`
`UsersByFirstName("abcd")`
`<end>`

Exemple de fractionnement

Vous trouverez ci-dessous quelques exemples de fractionnement pour vous aider à comprendre à quoi ils ressemblent.

SPLIT_START et SPLIT_LIMIT peuvent indiquer la ligne d'un tableau ou d'un index, ou peuvent être <begin> et <end>, représentant les limites de l'espace de clés de la base de données. Les SPLIT_START et SPLIT_LIMIT peuvent également contenir des clés tronquées, qui sont des clés précédant toute clé complète dans le tableau. Par exemple, Threads(10) est un préfixe pour toute ligne Threads intercalée dans Users(10).

SPLIT_START	SPLIT_LIMIT	AFFECTED_TABLES	EXPLICATION
`Users(3)`	`Users(10)`	`UsersByFirstName`, `Users`, `Threads`, `Messages` et `MessagesIdx`	La division commence à la ligne `UserId=3` et se termine à la ligne précédant celle avec `UserId = 10`. La fraction contient les lignes de la table `Users` et toutes les lignes de ses tables entrelacées pour `UserId=3` à 10.
`Messages(3,"a",1)`	`Threads(3,"aa")`	`Threads`, `Messages`, `MessagesIdx`	La division commence à la ligne avec `UserId=3`, `ThreadId="a"` et `MessageId=1` et se termine à la ligne précédant celle avec la clé `UserId=3` et `ThreadsId = "aa"`. La répartition contient toutes les tables entre `Messages(3,"a",1)` et `Threads(3,"aa")`. Comme `split_start` et `split_limit` sont entrelacées dans la même ligne de tableau de premier niveau, la division contient les lignes de tables entrelacées entre le début et la limite. Consultez schemas-overview pour comprendre comment les tables entrelacées sont colocalisées.
`Messages(3,"a",1)`	`<end>`	`UsersByFirstName`, `Users`, `Threads`, `Messages` et `MessagesIdx`	La division commence dans la table des messages au niveau de la ligne avec la clé `UserId=3`, `ThreadId="a"` et `MessageId=1`. La division héberge toutes les lignes de `split_start` à `<end>`, la fin de l'espace de clés de la base de données. Toutes les lignes des tables suivant `split_start`, comme `Users(4)`, sont incluses dans la division.
`<begin>`	`Users(9)`	`UsersByFirstName`, `Users`, `Threads`, `Messages` et `MessagesIdx`	La division commence à `<begin>`, au début de l'espace de clés de la base de données, et se termine à la ligne précédant la ligne `Users` avec `UserId=9`. La division contient donc toutes les lignes de la table précédant `Users`, toutes les lignes de la table `Users` précédant `UserId=9` et les lignes de ses tables entrelacées.
`Messages(3,"a",1)`	`Threads(10)`	`UsersByFirstName`, `Users`, `Threads`, `Messages` et `MessagesIdx`	La division commence à `Messages(3,"a", 1)` intercalé dans `Users(3)` et se termine à la ligne précédant `Threads(10)`. `Threads(10)` est une clé de fractionnement tronquée qui est un préfixe de n'importe quelle clé de la table Threads entrelacée dans `Users(10)`.
`Users()`	`<end>`	`UsersByFirstName`, `Users`, `Threads`, `Messages` et `MessagesIdx`	La division commence à la clé de division tronquée de `Users()`, qui précède toute clé complète de la table `Users`. La division s'étend jusqu'à la fin de l'espace de clés possible dans la base de données. Les tables concernées couvrent donc la table `Users`, ses tables et index entrelacés, ainsi que toutes les tables qui peuvent apparaître après les utilisateurs.
`Threads(10)`	`UsersByFirstName("abc")`	`UsersByFirstName`, `Users`, `Threads`, `Messages` et `MessagesIdx`	La division commence à la ligne `Threads` avec `UserId = 10` et se termine à l'index `UsersByFirstName` à la clé précédant `"abc"`.

Types `UNSPLITTABLE_REASONS`

Lorsque Spanner ne peut pas atténuer un point chaud par le biais d'une répartition basée sur la charge, la colonne UNSPLITTABLE_REASONS des vues SPLIT_STATS_TOP_* cite une ou plusieurs des raisons suivantes :

`HOT_ROW`

Description : la charge élevée est concentrée sur une seule ligne. Spanner ne peut pas ajouter de points de fractionnement dans une ligne individuelle.

Causes courantes :

Opérations fréquentes et volumineuses (lectures, écritures ou mises à jour) sur une seule clé.
Conceptions de schéma qui centralisent l'accès à une seule ligne.