Métricas del sistema en PostgreSQL

Imagina que tu servidor PostgreSQL es un restaurante, y nosotros somos los inspectores. Para que el restaurante funcione bien, tenemos que tener en cuenta cuántos ingredientes (CPU, memoria, disco) se usan, con qué frecuencia se acaban y quién los consume. Si nos despistamos, nuestro "restaurante" puede aceptar demasiados pedidos y colapsar, o simplemente caerse en medio del día. Por eso, entender las métricas del sistema es vital.

Métricas clave para monitorizar PostgreSQL:

1. CPU: indica cuánto tiempo de procesador se gasta ejecutando consultas.
2. Memoria (RAM): muestra cómo PostgreSQL usa la memoria RAM, incluyendo el caché de consultas.
3. Espacio en disco: probablemente la más predecible: no puedes guardar más datos de los que permite el disco.

Nuestro objetivo es aprender a revisar e interpretar las métricas del sistema en PostgreSQL para evitar problemas de rendimiento y falta de recursos.

Monitorización del uso de CPU

El procesador es el corazón de tu servidor. PostgreSQL puede consumir CPU tanto para ejecutar consultas complejas como para tareas en segundo plano, como el autoanálisis y la limpieza automática de la base (autovacuum). Si tu base de datos parece un comilón insaciable que devora la CPU, es hora de intervenir.

1. Uso de herramientas del sistema.
   Para empezar, identifica cuánta CPU consume PostgreSQL a nivel de sistema. En Linux puedes usar los comandos top o htop.

Busca el proceso de PostgreSQL (normalmente contiene el nombre de tu base de datos). Por ejemplo, postgres: postgres [your_query].

Fíjate en la columna %CPU. Si siempre está "a tope", es una señal de alarma.

2. Análisis de la carga de CPU desde PostgreSQL.

PostgreSQL ofrece vistas internas para monitorizar la carga. La más útil aquí es pg_stat_activity, que muestra las consultas activas.

Ejemplo de consulta:

SELECT pid, usename, query, state, now() - query_start AS duration
FROM pg_stat_activity
WHERE state = 'active'
ORDER BY duration DESC;

¿Qué es importante aquí?

• state = 'active' mostrará solo las consultas que se están ejecutando ahora mismo.
• duration mostrará cuánto tiempo llevan esas consultas usando la CPU.

Consejo práctico:

Si ves una consulta larga que no debería tardar tanto, revisa qué índices se están usando. También puedes terminar el proceso problemático usando pg_terminate_backend.

Ejemplo de terminación:

SELECT pg_terminate_backend(pid)
FROM pg_stat_activity
WHERE state = 'active' AND duration > interval '10 minutes';

Monitorización del uso de memoria

La memoria es el segundo recurso más importante para PostgreSQL, especialmente cuando se trata de cachear datos. PostgreSQL usa activamente la RAM (a través de los parámetros work_mem y shared_buffers) para acelerar las operaciones.

1. Parámetros principales de PostgreSQL para el uso de memoria:

• shared_buffers: Es el bloque principal de memoria reservado para PostgreSQL. Normalmente ocupa entre el 25% y el 40% de toda la RAM del servidor.
• work_mem: Memoria para operaciones de ordenación y hash en una consulta. Cuanto mayor sea el valor, más operaciones temporales se pueden hacer en memoria (y no en disco).

2. Comprobación de la configuración actual de memoria.

Para ver qué configuración de memoria está activa en PostgreSQL, ejecuta:

SHOW shared_buffers;
SHOW work_mem;

Ejemplo de salida:

1GB
4MB

Esto significa que el servidor tiene 1 GB de RAM reservado para shared_buffers y 4 MB para cada operación de ordenación/hash.

3. Monitorización de memoria con pg_stat_activity

Puedes comprobar cuánta memoria usan las conexiones actuales. Para eso hay una consulta útil:

SELECT pid, usename, state, backend_start, pg_size_pretty(pg_backend_memory_contexts_size(pid)) AS memory_used
FROM pg_stat_activity
WHERE state = 'active'
ORDER BY memory_used DESC;

Esta consulta muestra cuánta RAM está usando cada conexión activa.

Consejo: si una conexión consume demasiada memoria, revisa si la consulta tiene operaciones de ordenación o agregación que se puedan optimizar.

Monitorización del espacio en disco

El disco es el último depósito de recursos para PostgreSQL. Incluso si tienes suficiente memoria y CPU, PostgreSQL necesita espacio en disco para guardar datos, logs de transacciones (WAL) y archivos temporales.

1. Comprobación del tamaño de la base de datos.

Empecemos por lo básico: ver el tamaño de la base de datos.

SELECT pg_size_pretty(pg_database_size(current_database())) AS db_size;

¿Qué hace esta consulta?

Muestra el tamaño total de la base actual en un formato cómodo (MB, GB).

2. Comprobación del tamaño de tablas e índices.

Para identificar las "pesadas" en la base de datos, usa:

SELECT relname AS table_name, pg_size_pretty(pg_total_relation_size(relid)) AS total_size
FROM pg_catalog.pg_statio_user_tables
ORDER BY pg_total_relation_size(relid) DESC;

Ejemplo de salida:

3. Monitorización de WAL (logs de transacciones).

Si tienes una base de datos activa, los logs de transacciones pueden crecer rápido. Para ver su tamaño:

SELECT pg_size_pretty(pg_xlog_location_diff(pg_current_wal_lsn(), '0/0')) AS wal_size;

Conclusiones

Ahora tienes las herramientas y el conocimiento para vigilar las métricas del sistema en PostgreSQL:

1. Usa htop o pg_stat_activity para monitorizar la carga de CPU.
2. Ajusta los parámetros shared_buffers y work_mem para un uso óptimo de la memoria.
3. Revisa regularmente el tamaño de la base de datos, tablas e índices para evitar quedarte sin espacio en disco.

Estas habilidades te servirán para evitar caídas inesperadas y mantener tu servidor PostgreSQL en plena forma. Piensa en el servidor: unos recursos bien organizados harán que tu producto sea el favorito de los clientes (usuarios).