Estadísticas de división

En esta página, se describe cómo detectar y depurar los puntos críticos de tu base de datos. Puedes acceder a estadísticas sobre los puntos de acceso en divisiones con GoogleSQL y PostgreSQL.

Spanner almacena tus datos como un espacio de claves contiguo, ordenado por las claves primarias de tus tablas e índices. Una división es un rango de filas de un conjunto de tablas o un índice. El inicio de la división se denomina inicio de la división. El límite de división establece el final de la división. La división incluye el inicio de la división, pero no el límite de la división.

En Spanner, los hotspots son situaciones en las que se envían demasiadas solicitudes al mismo servidor, lo que satura los recursos del servidor y puede causar latencias altas. Las divisiones afectadas por los hotspots se conocen como divisiones activas o cálidas.

La estadística de hotspot de una división (identificada en el sistema como CPU_USAGE_SCORE) es una medición de la carga en una división que está restringida por los recursos disponibles en el servidor. Esta medición se expresa como un porcentaje. Si más del 50% de la carga en una división está restringida por los recursos disponibles, se considera que la división está caliente. Si el 100% de la carga en una división está restringido, se considera que la división está activa.

Spanner usa la división basada en la carga para distribuir de manera uniforme la carga de datos entre los servidores de la instancia. Las divisiones cálidas y calientes se pueden mover entre servidores para el balanceo de cargas o se pueden dividir en divisiones más pequeñas. Sin embargo, es posible que Spanner no pueda equilibrar la carga, incluso después de varios intentos de división, debido a antipatrones en la aplicación. Por lo tanto, es posible que los puntos de acceso persistentes que duran al menos 10 minutos requieran una solución de problemas adicional y posibles cambios en la aplicación.

Las estadísticas de divisiones sobrecargadas de Spanner te ayudan a identificar las divisiones en las que se producen hotspots. Luego, podrás realizar los cambios necesarios en tu aplicación o esquema. Puedes recuperar estas estadísticas de las tablas del sistema SPANNER_SYS.SPLIT_STATS_TOP_MINUTE con instrucciones de SQL.

Cómo acceder a las estadísticas de divisiones destacadas

Spanner proporciona las estadísticas de división activa en el esquema SPANNER_SYS. Los datos de SPANNER_SYS solo están disponibles a través de las interfaces de GoogleSQL y PostgreSQL. Puedes acceder a estos datos de las siguientes maneras:

• La página de Spanner Studio de una base de datos en la consola de Google Cloud
• El comando gcloud spanner databases execute-sql
• El método executeSql o el método executeStreamingSql.

Los siguientes métodos de lectura única que proporciona Spanner no son compatibles con SPANNER_SYS:

• Realizar una lectura sólida desde una o varias filas de una tabla
• Realizar una lectura inactiva desde una o varias filas en una tabla
• Leer desde una o varias filas en un índice secundario

Estadísticas de divisiones con mayor actividad

Usa la siguiente tabla para hacer un seguimiento de las divisiones sobrecargadas:

• SPANNER_SYS.SPLIT_STATS_TOP_MINUTE: Muestra los tramos populares durante intervalos de 1 minuto.

Estas tablas tienen las siguientes propiedades:

• Cada tabla contiene datos de intervalos de tiempo no superpuestos de la duración que se especifica en el nombre de la tabla.

• Los intervalos se basan en tiempos de reloj:

  • Los intervalos de 1 minuto finalizan en el minuto.

• Después de cada intervalo, Spanner recopila datos de todos los servidores y, luego, los pone a disposición en las tablas SPANNER_SYS poco después.

  Por ejemplo, a las 11:59:30 a.m., los intervalos más recientes disponibles para las consultas de SQL son los siguientes:

  • 1 minuto: de 11:58:00 a.m. a 11:58:59 a.m.

• Spanner agrupa las estadísticas por divisiones.

• Cada fila contiene un porcentaje que indica qué tan caliente o tibia es una división, para cada división de la que Spanner captura estadísticas durante el intervalo especificado.

• Si menos del 50% de la carga en una división está restringida por los recursos disponibles, Spanner no registra la estadística. Si Spanner no puede almacenar todas las divisiones activas durante el intervalo, el sistema prioriza las divisiones con el porcentaje de CPU_USAGE_SCORE más alto durante el intervalo especificado. Si no se devuelven divisiones, esto indica la ausencia de puntos de interés.

Esquema de la tabla

En la siguiente tabla, se muestra el esquema de la tabla para las siguientes estadísticas:

• SPANNER_SYS.SPLIT_STATS_TOP_MINUTE

Claves de inicio y límite de división

Una división es un rango de filas contiguas de una base de datos y se define por sus claves de inicio y límite. Una división puede ser una sola fila, un rango de filas estrecho o un rango de filas amplio, y puede incluir varias tablas o índices.

Las columnas SPLIT_START y SPLIT_LIMIT identifican las claves primarias de una división cálida o activa.

Esquema de ejemplo

El siguiente esquema es una tabla de ejemplo para los temas de esta página.

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;

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

Imagina que tu espacio de claves se ve de la siguiente manera:

Ejemplo de divisiones

A continuación, se muestran algunos ejemplos de divisiones para ayudarte a comprender cómo se ven.

SPLIT_START y SPLIT_LIMIT pueden indicar la fila de una tabla o un índice, o bien pueden ser <begin> y <end>, que representan los límites del espacio de claves de la base de datos. SPLIT_START y SPLIT_LIMIT también pueden contener claves truncadas, que son claves que preceden a cualquier clave completa en la tabla. Por ejemplo, Threads(10) es un prefijo para cualquier fila Threads intercalada en Users(10).

Ejemplos de consultas para encontrar divisiones populares

En el siguiente ejemplo, se muestra una instrucción de SQL que puedes usar para recuperar las estadísticas de división activa. Puedes ejecutar estas instrucciones de SQL con las bibliotecas cliente, gcloud o la consola de Google Cloud .

SELECT t.split_start,
       t.split_limit,
       t.cpu_usage_score,
       t.affected_tables,
FROM   SPANNER_SYS.SPLIT_STATS_TOP_MINUTE t
WHERE  t.interval_end =
  (SELECT MAX(interval_end)
  FROM    SPANNER_SYS.SPLIT_STATS_TOP_MINUTE)
ORDER BY  t.cpu_usage_score DESC;

SELECT t.split_start,
       t.split_limit,
       t.cpu_usage_score,
       t.affected_tables
FROM   SPANNER_SYS.SPLIT_STATS_TOP_MINUTE t
WHERE  t.interval_end = (
  SELECT MAX(interval_end)
  FROM   SPANNER_SYS.SPLIT_STATS_TOP_MINUTE
)
ORDER BY t.cpu_usage_score DESC;

El resultado de la consulta se verá de la siguiente manera:

Retención de datos para las estadísticas de la división activa

Como mínimo, Spanner conserva los datos para cada tabla durante el siguiente período:

• SPANNER_SYS.SPLIT_STATS_TOP_MINUTE: Intervalos que abarcan las 6 horas anteriores.

Soluciona problemas de hotspots con estadísticas de divisiones activas

En esta sección, se describe cómo detectar y solucionar problemas relacionados con los puntos de acceso.

Selecciona un período para investigar

Verifica las métricas de latencia de tu base de datos de Spanner para encontrar el período en el que tu aplicación experimentó una latencia y un uso de CPU altos. Por ejemplo, podría mostrarte que un problema comenzó alrededor de las 10:50 p.m. del 18 de mayo de 2024.

Cómo encontrar el hotspotting persistente

A medida que Spanner equilibra tu carga con la división basada en la carga, te recomendamos que investigues si el hotspotting continuó durante más de 10 minutos. Para ello, consulta la tabla SPANNER_SYS.SPLIT_STATS_TOP_MINUTE, como se muestra en el siguiente ejemplo:

SELECT Count(DISTINCT t.interval_end)
FROM   SPANNER_SYS.SPLIT_STATS_TOP_MINUTE t
WHERE  t.cpu_usage_score >= 50
  AND  t.interval_end >= "interval_end_date_time"
  AND  t.interval_end <= "interval_end_date_time";

SELECT COUNT(DISTINCT t.interval_end)
FROM   SPLIT_STATS_TOP_MINUTE t
WHERE  t.cpu_usage_score >= 50
  AND  t.interval_end >= 'interval_end_date_time'::timestamptz
  AND  t.interval_end <= 'interval_end_date_time'::timestamptz;

Si el resultado de la consulta anterior es igual a 10, significa que tu base de datos experimenta hotspotting, lo que podría requerir una depuración adicional.

Encuentra las divisiones con el nivel de CPU_USAGE_SCORE más alto

En este ejemplo, ejecutamos el siguiente código SQL para encontrar los rangos de filas con el nivel de CPU_USAGE_SCORE más alto:

SELECT t.split_start,
       t.split_limit,
       t.affected_tables,
       t.cpu_usage_score
FROM   SPANNER_SYS.SPLIT_STATS_TOP_MINUTE t
WHERE  t.cpu_usage_score >= 50
  AND  t.interval_end = "interval_end_date_time";

SELECT t.split_start,
       t.split_limit,
       t.affected_tables,
       t.cpu_usage_score
FROM   SPLIT_STATS_TOP_MINUTE t
WHERE  t.cpu_usage_score = 100
  AND  t.interval_end = 'interval_end_date_time'::timestamptz;

El SQL anterior genera el siguiente resultado:

En esta tabla de resultados, podemos ver que los puntos críticos se produjeron en dos divisiones. La división basada en la carga de Spanner podría intentar resolver los puntos calientes en estas divisiones. Sin embargo, es posible que no pueda hacerlo si hay patrones problemáticos en el esquema o la carga de trabajo. Para detectar si hay divisiones que requieren tu intervención, te recomendamos que las supervises durante al menos 10 minutos. Por ejemplo, el siguiente código SQL hace un seguimiento de la primera división en los últimos diez minutos.

SELECT t.interval_end,
       t.split_start,
       t.split_limit,
       t.cpu_usage_score
FROM   SPANNER_SYS.SPLIT_STATS_TOP_MINUTE t
WHERE  t.split_start = "users(180)"
  AND  t.split_limit = "<end>"
  AND  t.interval_end >= "interval_end_date_time"
  AND  t.interval_end <= "interval_end_date_time";

SELECT t.interval_end,
       t.split_start,
       t.split_limit,
       t.cpu_usage_score
FROM   SPANNER_SYS.SPLIT_STATS_TOP_MINUTE t
WHERE  t.split_start = 'users(180)'
  AND  t.split_limit = ''
  AND  t.interval_end >= 'interval_end_date_time'::timestamptz
  AND  t.interval_end <= 'interval_end_date_time'::timestamptz;

El SQL anterior genera el siguiente resultado:

Parece que la división ha estado activa durante los últimos minutos. Es posible que observes la división durante más tiempo para determinar que la división basada en la carga de Spanner mitiga el hotspot. Es posible que haya casos en los que Spanner no pueda balancear la carga más.

Por ejemplo, consulta la tabla SPANNER_SYS.SPLIT_STATS_TOP_MINUTE. Consulta los siguientes ejemplos de situaciones.

SELECT t.interval_end,
      t.split_start,
      t.split_limit,
      t.cpu_usage_score
FROM  SPANNER_SYS.SPLIT_STATS_TOP_MINUTE t
WHERE t.interval_end >= "interval_end_date_time"
      AND t.interval_end <= "interval_end_date_time";

SELECT t.interval_end,
       t.split_start,
       t.split_limit,
       t._cpu_usage
FROM   SPANNER_SYS.SPLIT_STATS_TOP_MINUTE t
WHERE  t.interval_end >= 'interval_end_date_time'::timestamptz
  AND  t.interval_end <= 'interval_end_date_time'::timestamptz;

Fila activa única

En el siguiente ejemplo, parece que Threads(10,"spanner") se encuentra en una división de una sola fila que permaneció activa durante más de 10 minutos. Esto podría ocurrir cuando hay una carga persistente en una fila popular.

Spanner no puede balancear la carga para esta clave única, ya que no se puede dividir más.

Hotspot en movimiento

En el siguiente ejemplo, la carga se desplaza a través de divisiones contiguas con el tiempo y se mueve a una nueva división en los intervalos de tiempo.

Esto podría ocurrir, por ejemplo, debido a una carga de trabajo que lee o escribe claves en orden monótonamente creciente. Spanner no puede balancear la carga para mitigar los efectos de este comportamiento de la aplicación.

Balanceo de cargas normal

Spanner intenta equilibrar la carga agregando más divisiones o moviéndolas. En el siguiente ejemplo, se muestra cómo podría verse.

Aquí, la división más grande del 2024-05-16T17:40:00Z se dividió aún más en una división más pequeña y, como resultado, la estadística CPU_USAGE_SCORE disminuyó. Es posible que Spanner no cree divisiones en filas individuales. Las divisiones reflejan la carga de trabajo que provoca la alta estadística de CPU_USAGE_SCORE.

Si observaste una división activa persistente durante más de 10 minutos, consulta Prácticas recomendadas para mitigar los puntos activos.

Prácticas recomendadas para mitigar los puntos de acceso

Si el balanceo de cargas no disminuye la latencia, el siguiente paso es identificar la causa de los puntos calientes. Después de eso, las opciones son reducir la carga de trabajo de los puntos calientes o bien optimizar el esquema y la lógica de la aplicación para evitarlos.

Identifica la causa

• Usa Lock & Transaction Insights para buscar transacciones que tengan un tiempo de espera de bloqueo alto en el que la clave de inicio del rango de filas esté dentro de la división activa.

• Usa Estadísticas de consultas para buscar consultas que lean desde la tabla que contiene la división activa y que hayan aumentado la latencia recientemente o tengan una proporción más alta de latencia en relación con la CPU.

• Usa Oldest Active Queries para buscar consultas que lean desde la tabla que contiene la división activa y que tengan una latencia más alta de lo esperado.

Estos son algunos casos especiales que debes tener en cuenta:

• Comprueba si el tiempo de actividad (TTL) se habilitó recientemente. Si hay muchas divisiones de datos antiguos, el TTL puede aumentar los niveles de CPU_USAGE_SCORE durante las eliminaciones masivas. En este caso, el problema debería resolverse por sí solo una vez que se completen las eliminaciones iniciales.

Optimiza la carga de trabajo

• Sigue las prácticas recomendadas sobre SQL. Considera las lecturas obsoletas, las escrituras que no realizan lecturas primero o la adición de índices.
• Sigue las prácticas recomendadas para el esquema. Asegúrate de que tu esquema esté diseñado para controlar el balanceo de cargas y evitar la generación de hotspots.

¿Qué sigue?

• Obtén más información sobre las prácticas recomendadas para el diseño de esquemas.
• Obtén más información sobre Key Visualizer.
• Consulta los ejemplos de diseños de esquema.
• Obtén información para usar el panel de estadísticas de división y detectar hotspots.