Cómo instalar y usar TimescaleDB en CentOS 7

El autor seleccionó el Computer History Museum para recibir una donación como parte del programa Write for DOnations.

Introducción

Muchas aplicaciones, como los sistemas de monitoreo y recopilación de datos, acumulan información para analizarla en mayor profundidad. En estos análisis, se suele examinar la forma en que cambia un dato o un sistema con el paso del tiempo. En estos casos, los datos se representan como series temporales en las que cada punto de datos va acompañado de una marca de tiempo. Un ejemplo tendría el siguiente aspecto:

2019-11-01 09:00:00    server.cpu.1    0.9
2019-11-01 09:00:00    server.cpu.15   0.8
2019-11-01 09:01:00    server.cpu.1    0.9
2019-11-01 09:01:00    server.cpu.15   0.8
...

La relevancia de los datos de series temporales aumentó recientemente gracias a las nuevas implementaciones de la Internet de las cosas (IoT) e la Internet de las cosas industrial. Cada vez hay más dispositivos que recopilan información de varias series temporales: monitores de actividad física, relojes inteligentes, estaciones meteorológicas domésticas y diversos sensores, por nombrar algunos ejemplos. Estos dispositivos recopilan mucha información, y todos estos datos deben almacenarse en algún lugar.

Para almacenar datos suelen utilizarse bases de datos relacionales clásicas, pero estas no siempre son adecuadas cuando se trata de los enormes volúmenes de datos de las series temporales. Cuando se debe procesar una gran cantidad de datos de series temporales, las bases de datos relacionales pueden ser demasiado lentas. Por ello, se crearon bases de datos especialmente optimizadas llamadas bases de datos NoSQL, para evitar los problemas de las bases de datos relacionales.

TimescaleDB es una base de datos de código abierto optimizada que se utiliza para almacenar datos de series temporales. Se implementa como una extensión de PostgreSQL y en ella se combinan la facilidad de uso de las bases de datos relacionales y la velocidad de las bases de datos NoSQL. Como resultado, le permite usar PostgreSQL para almacenar datos empresariales y de series temporales en un solo lugar.

Siguiendo los pasos de este tutorial, instalará TimescaleDB en CentOS 7, la configurará y aprenderá a usarla. También creará bases de datos de series temporales y realizará consultas simples. Por último, aprenderá a eliminar datos innecesarios.

Requisitos previos

Para este tutorial, necesitará lo siguiente:

• Un servidor de CentOS 7 configurado siguiendo nuestra Guía de configuración inicial de servidores para CentOS 7 con un usuario no root con privilegios sudo y un firewall configurado con firewalld. Para configurar firewalld, siga los pasos de la sección “Configurar un firewall básico” del tutorial Pasos adicionales recomendados para servidores de CentOS 7 nuevos.
• PostgreSQL instalado en su servidor. Siga nuestra guía Cómo instalar y usar PostgreSQL en CentOS 7 para instalarlo y configurarlo.

Paso 1: Instalar TimescaleDB

TimescaleDB no está disponible en los repositorios de paquetes predeterminados de CentOS. Por lo tanto, a través de este paso la instalará desde un repositorio de terceros de TimescaleDB.

Primero, cree un nuevo archivo de repositorio:

sudo vi /etc/yum.repos.d/timescaledb.repo

Ingrese en el modo de inserción presionando i y pegue la siguiente configuración en el archivo:

[timescale_timescaledb]
name=timescale_timescaledb
baseurl=https://packagecloud.io/timescale/timescaledb/el/7/$basearch
repo_gpgcheck=1
gpgcheck=0
enabled=1
gpgkey=https://packagecloud.io/timescale/timescaledb/gpgkey
sslverify=1
sslcacert=/etc/pki/tls/certs/ca-bundle.crt
metadata_expire=300

Cuando termine, presione ESC para salir del modo de inserción, y luego :wq y ENTER para guardar y cerrar el archivo. Para obtener más información sobre el editor de texto Vi y su sucesor Vim, consulte nuestro tutorial Cómo instalar y utilizar el editor de texto Vim en servidores en la nube.

Ahora, puede proceder con la instalación. En este tutorial, se utiliza la versión 11 de PostgreSQL; si utiliza una diferente (la 9.6 o la 10, por ejemplo), sustituya el valor en el siguiente comando y ejecútelo:

sudo yum install -y timescaledb-postgresql-11

Ahora, TimescaleDB quedará instalada y lista para la usarse. A continuación, la activará y ajustará algunos parámetros relacionados con ella en el archivo de configuración de PostgreSQL para optimizar la base de datos.

Paso 2: Configurar TimescaleDB

El módulo TimescaleDB funciona bien con la configuración predeterminada de PostgreSQL. Sin embargo, para mejorar el rendimiento y aprovechar mejor los recursos del procesador, de la memoria y del disco, los desarrolladores de TimescaleDB sugieren ajustar algunos parámetros individuales. Esto se puede realizar de forma automática con la herramienta timescaledb-tune. Como alternativa, puede editar el archivo postgresql.conf de su servidor de forma manual.

A través de este tutorial, utilizará la herramienta timescaledb-tune. Lee el archivo postgresql.conf y realiza cambios de forma interactiva.

Ejecute el siguiente comando para iniciar el asistente de configuración:

sudo timescaledb-tune --pg-config=/usr/pgsql-11/bin/pg_config

Primero, se le solicitará que confirme la ruta al archivo de configuración de PostgreSQL:

Output
Using postgresql.conf at this path:
/var/lib/pgsql/11/data/postgresql.conf

Is this correct? [(y)es/(n)o]:

La herramienta detecta la ruta al archivo de configuración de forma automática. Por lo tanto, debe confirmar esto ingresando y:

Output
...
Is this correct? [(y)es/(n)o]: y
Writing backup to:
/tmp/timescaledb_tune.backup201912191633

A continuación, habilite el módulo TimescaleDB ingresando y en el siguiente mensaje y presionando ENTER:

Output
shared_preload_libraries needs to be updated
Current:
#shared_preload_libraries = ''
Recommended:
shared_preload_libraries = 'timescaledb'
Is this okay? [(y)es/(n)o]:  y
success: shared_preload_libraries will be updated

Luego, tendrá la posibilidad de ajustar la configuración en función de las características de su servidor y la versión de PostgreSQL, Presione y para iniciar el proceso de ajuste:

Output
Tune memory/parallelism/WAL and other settings? [(y)es/(n)o]:  y
Recommendations based on 7.64 GB of available memory and 4 CPUs for PostgreSQL 11

Memory settings recommendations
Current:
shared_buffers = 128MB
#effective_cache_size = 4GB
#maintenance_work_mem = 64MB
#work_mem = 4MB
Recommended:
shared_buffers = 1955MB
effective_cache_size = 5865MB
maintenance_work_mem = 1001121kB
work_mem = 5005kB
Is this okay? [(y)es/(s)kip/(q)uit]:

La herramienta timescaledb-tune detectará la memoria disponible en el servidor y calculará los valores recomendados para la configuración de shared_buffers, effective_cache_size, maintenance_work_mem, y work_mem de forma automática. Si desea obtener más información sobre cómo se realiza esta acción, consulte la página de GitHub sobre timescaledb-tune.

Si estas configuraciones son correctas, ingrese y:

Output
...
Is this okay? [(y)es/(s)kip/(q)uit]:  y
success: memory settings will be updated

En este momento, si su servidor tiene varias CPU, verá las recomendaciones para la configuración de paralelismo. Sin embargo, si cuenta con una sola CPU, timescaledb-tune lo dirigirá directamente a la configuración de WAL.

Los servidores con varias CPU recibirán recomendaciones como esta:

Output
Parallelism settings recommendations
Current:
missing: timescaledb.max_background_workers
#max_worker_processes = 8
#max_parallel_workers_per_gather = 2
#max_parallel_workers = 8
Recommended:
timescaledb.max_background_workers = 8
max_worker_processes = 15
max_parallel_workers_per_gather = 2
max_parallel_workers = 4
Is this okay? [(y)es/(s)kip/(q)uit]:

Estos ajustes regulan la cantidad de trabajadores que procesan las solicitudes y las tareas en segundo plano. Puede obtener más información sobre estos ajustes en la documentación de TimescaleDB y PostgreSQL.

Ingrese y y luego ENTER para aceptar estos ajustes:

Output
...
Is this okay? [(y)es/(s)kip/(q)uit]: y
success: parallelism settings will be updated

A continuación, verá las recomendaciones para Write Ahead Log (WAL):

Output
WAL settings recommendations
Current:
#wal_buffers = -1
#min_wal_size = 80MB
#max_wal_size = 1GB
Recommended:
wal_buffers = 16MB
min_wal_size = 4GB
max_wal_size = 8GB
Is this okay? [(y)es/(s)kip/(q)uit]:

WAL preserva la integridad de los datos, pero los ajustes predeterminados pueden provocar una E/S deficiente que ralentice el rendimiento de escritura. Escriba e ingrese y para optimizar estos ajustes:

Output
...
Is this okay? [(y)es/(s)kip/(q)uit]: y
success: WAL settings will be updated

Ahora, verá algunas recomendaciones variadas:

Output
Miscellaneous settings recommendations
Current:
#default_statistics_target = 100
#random_page_cost = 4.0
#checkpoint_completion_target = 0.5
#max_locks_per_transaction = 64
#autovacuum_max_workers = 3
#autovacuum_naptime = 1min
#effective_io_concurrency = 1
Recommended:
default_statistics_target = 500
random_page_cost = 1.1
checkpoint_completion_target = 0.9
max_locks_per_transaction = 64
autovacuum_max_workers = 10
autovacuum_naptime = 10
effective_io_concurrency = 200
Is this okay? [(y)es/(s)kip/(q)uit]:

El objetivo de todos estos parámetros diferentes es mejorar el rendimiento. Por ejemplo, las SSD pueden procesar varias solicitudes a la vez, por lo que el mejor valor para effective_io_concurrency podría estar en el orden de los cientos. Puede obtener más información sobre estas opciones en la documentación de PostgreSQL.

Presione y y luego ENTER para continuar.

Output
...
Is this okay? [(y)es/(s)kip/(q)uit]: y
success: miscellaneous settings will be updated
Saving changes to: /var/lib/pgsql/11/data/postgresql.conf

Como resultado, obtendrá un archivo de configuración preparado en /var/lib/pgsql/11/data/postgresql.conf.

sudo timescaledb-tune --pg-config=/usr/pgsql-11/bin/pg_config --quiet --yes

Para que los cambios de la configuración surtan efecto, debe reiniciar el servicio de PostgreSQL:

sudo systemctl restart postgresql-11.service

Ahora, la base de datos funcionará con los parámetros óptimos y estará lista para trabajar con los datos de series temporales. En los siguientes pasos, probará trabajar con estos datos: creará nuevas bases de datos e hypertables y realizará operaciones.

Paso 3: Crear una nueva base de datos y hypertable

Una vez optimizada la configuración de TimescaleDB, estará listo para trabajar con datos de series temporales. TimescaleDB se implementa como una extensión de PostgreSQL. Por lo tanto, las operaciones con datos de series temporales no difieren mucho de las operaciones con datos relacionales. A su vez, la base de datos le permite combinar libremente datos de series temporales y tablas relacionales en el futuro.

Primero, creará una nueva base de datos y activará la extensión de TimescaleDB para ella. Inicie sesión en su base de datos de PostgreSQL:

sudo -u postgres psql

Ahora, cree una nueva base de datos y conéctese a ella. En este tutorial, la llamaremos timeseries:

CREATE DATABASE timeseries;
\c timeseries

Puede obtener información adicional sobre cómo trabajar con la base de datos de PostgreSQL en nuestro tutorial Cómo crear, eliminar y administrar tablas en PostgreSQL en servidores en la nube.

Por último, habilite la extensión de TimescaleDB:

CREATE EXTENSION IF NOT EXISTS timescaledb CASCADE;

Verá lo siguiente:

Output
WARNING:
WELCOME TO
 _____ _                               _     ____________
|_   _(_)                             | |    |  _  \ ___ \
  | |  _ _ __ ___   ___  ___  ___ __ _| | ___| | | | |_/ /
  | | | |  _ ` _ \ / _ \/ __|/ __/ _` | |/ _ \ | | | ___ \
  | | | | | | | | |  __/\__ \ (_| (_| | |  __/ |/ /| |_/ /
  |_| |_|_| |_| |_|\___||___/\___\__,_|_|\___|___/ \____/
               Running version 1.5.1
For more information on TimescaleDB, please visit the following links:

 1. Getting started: https://docs.timescale.com/getting-started
 2. API reference documentation: https://docs.timescale.com/api
 3. How TimescaleDB is designed: https://docs.timescale.com/introduction/architecture

Note: TimescaleDB collects anonymous reports to better understand and assist our users.
For more information and how to disable, please see our docs https://docs.timescaledb.com/using-timescaledb/telemetry.

CREATE EXTENSION

El principal punto de interacción con los datos de series temporales son las hipertablas, una abstracción de muchas tablas individuales que contienen los datos, denominados fragmentos.

Para crear una hipertabla, comience con una tabla SQL normal y luego conviértala en hipertabla con la función create_hypertable.

Cree una tabla que almacene datos para realizar un seguimiento de la temperatura y la humedad en un conjunto de dispositivos con el paso del tiempo:

CREATE TABLE conditions (
  time        TIMESTAMP WITH TIME ZONE NOT NULL,
  device_id   TEXT,
  temperature  NUMERIC,
  humidity     NUMERIC
);

Este comando creará una tabla denominada conditions con cuatro columnas. En la primera se almacenará la marca de tiempo, que incluye la zona horaria y no puede estar vacía. A continuación, utilizará la columna de tiempo para transformar su tabla en una hipertabla dividida por tiempo:

SELECT create_hypertable('conditions', 'time');

Este comando invoca la función create_hypertable(), que crea una hipertabla de TimescaleDB a partir de una tabla de PostgreSQL y sustituye esta última.

Recibirá el siguiente resultado:

Output
    create_hypertable
-------------------------
 (1,public,conditions,t)
(1 row)

En este paso, creó una nueva hipertabla para almacenar datos de series temporales. Ahora, podrá completar esta tabla con datos, escribiendo en ella, y luego probar el proceso para eliminarla.

Paso 4: Escribir y eliminar datos

En este paso, insertará datos utilizando comandos SQL estándares e importará conjuntos de datos grandes de fuentes externas. Esto le mostrará los aspectos de las bases de datos relacionales de TimescaleDB.

Primero, pruebe los comandos básicos. Se pueden insertar datos en una hipertabla usando el comando de SQL estándar INSERT. Ingrese algunos datos de temperature y humidity de ejemplo para el dispositivo teóricoweather-pro-000000usando el siguiente comando:

INSERT INTO conditions(time, device_id, temperature, humidity)
  VALUES (NOW(), 'weather-pro-000000', 84.1, 84.1);

Recibirá el siguiente resultado:

Output
INSERT 0 1

También puede insertar varias filas de datos a la vez. Pruebe lo siguiente:

INSERT INTO conditions
  VALUES
    (NOW(), 'weather-pro-000002', 71.0, 51.0),
    (NOW(), 'weather-pro-000003', 70.5, 50.5),
    (NOW(), 'weather-pro-000004', 70.0, 50.2);

Verá lo siguiente:

Output
INSERT 0 3

También puede especificar que con el comando INSERT se muestre una parte o la totalidad de los datos insertados usando la instrucción RETURNING:

INSERT INTO conditions
  VALUES (NOW(), 'weather-pro-000002', 70.1, 50.1) RETURNING *;

Verá lo siguiente:

Output
             time              |     device_id      | temperature | humidity
-------------------------------+--------------------+-------------+----------
 2019-09-15 14:14:01.576651+00 | weather-pro-000002 |        70.1 |     50.1
(1 row)

Si desea eliminar datos de la hipertabla, utilice el comando de SQL estándar DELETE. Ejecute lo siguiente para eliminar todo dato en el que temperature sea superior a 80 o humidity sea superior a 50:

DELETE FROM conditions WHERE temperature > 80;
DELETE FROM conditions WHERE humidity > 50;

Después de la operación de eliminación, se recomienda usar el comando VACUUM, que recuperará espacio aún ocupado por datos eliminados.

VACUUM conditions;

Puede obtener más información sobre el comando VACUUM en la documentación de PostgreSQL.

Estos comandos funcionan bien para la entrada de datos en pequeña escala, pero, dado que los datos de series temporales suelen generar conjuntos de datos grandes de varios dispositivos de forma simultánea, también es fundamental saber cómo insertar cientos o miles de filas a la vez. Si preparó datos de fuentes externas en un formato estructurado, por ejemplo en formato csv, esta tarea se puede realizar rápidamente.

Para probar esto, utilizará un conjunto de datos de muestra que representa datos de temperatura y humedad de varias ubicaciones. Lo crearon los desarrolladores de TimescaleDB para que pueda probar su base de datos. Puede obtener más información sobre los conjuntos de datos de muestra en la documentación de TimescaleDB.

Veamos cómo puede importar datos del conjunto de datos de muestra weather_small a su base de datos. Primero, salga de PostgreSQL:

\q

Luego, descargue el conjunto de datos y extráigalo:

cd /tmp
curl https://timescaledata.blob.core.windows.net/datasets/weather_small.tar.gz -o weather_small.tar.gz
tar -xvzf weather_small.tar.gz

A continuación, importe los datos de temperatura y humedad a su base de datos:

sudo -u postgres psql -d timeseries -c "\COPY conditions FROM weather_small_conditions.csv CSV"

A través de esto, se establece conexión con la base de datos timeseries y se ejecuta el comando \COPY para copiar los datos del archivo seleccionado en la hipertabla conditions. Se ejecutará por unos segundos.

Cuando los datos se hayan ingresado a su tabla, verá el siguiente resultado:

Output
COPY 1000000

En este paso, agregó datos a la hipertabla de forma manual y en lotes. Luego, continúe realizando consultas.

Paso 5: Consultar datos

Ahora que su tabla contiene datos, puede realizar varias consultas para analizarla.

Para comenzar, inicie sesión en la base de datos:

sudo -u postgres psql -d timeseries

Como se mencionó anteriormente, para trabajar con hipertablas puede usar comandos SQL estándares. Por ejemplo, para mostrar las últimas 10 entradas de la hipertabla conditions, ejecute el siguiente comando:

SELECT * FROM conditions LIMIT 10;

Verá lo siguiente:

Output
          time          |     device_id      |    temperature     | humidity
------------------------+--------------------+--------------------+----------
 2016-11-15 12:00:00+00 | weather-pro-000000 |               39.9 |     49.9
 2016-11-15 12:00:00+00 | weather-pro-000001 |               32.4 |     49.8
 2016-11-15 12:00:00+00 | weather-pro-000002 | 39.800000000000004 |     50.2
 2016-11-15 12:00:00+00 | weather-pro-000003 | 36.800000000000004 |     49.8
 2016-11-15 12:00:00+00 | weather-pro-000004 |               71.8 |     50.1
 2016-11-15 12:00:00+00 | weather-pro-000005 |               71.8 |     49.9
 2016-11-15 12:00:00+00 | weather-pro-000006 |                 37 |     49.8
 2016-11-15 12:00:00+00 | weather-pro-000007 |                 72 |       50
 2016-11-15 12:00:00+00 | weather-pro-000008 |               31.3 |       50
 2016-11-15 12:00:00+00 | weather-pro-000009 |               84.4 |     87.8
(10 rows)

Este comando le permite ver los datos que contiene la base de datos. Debido a que la base de datos contiene un millón de registros, utilizó LIMIT 10 para limitar el resultado a 10 entradas.

Para ver las entradas más recientes, ordene la matriz de datos por tiempo aplicando un patrón descendente:

SELECT * FROM conditions ORDER BY time DESC LIMIT 20;

Con esto, se mostrarán las 20 entradas más recientes.

También puede añadir un filtro. Por ejemplo, para ver entradas del dispositivo weather-pro-000000, ejecute lo siguiente:

SELECT * FROM conditions WHERE device_id = 'weather-pro-000000' ORDER BY time DESC LIMIT 10;

En este caso, verá los 10 puntos de datos de temperatura y humedad más recientes registrados en el dispositivo weather-pro-000000.

Además de comandos SQL estándares, TimescaleDB también proporciona varias funciones especiales que son útiles para el análisis de datos de series temporales. Por ejemplo, para determinar la mediana de los valores de temperatura, puede usar la siguiente consulta con la función percentile_cont:

SELECT percentile_cont(0.5)
  WITHIN GROUP (ORDER BY temperature)
  FROM conditions
  WHERE device_id = 'weather-pro-000000';

Verá lo siguiente:

Output
 percentile_cont
-----------------
            40.5
(1 row)

De esta manera, verá la temperatura media para todo el período de observación en el que se encuentra el sensor weather-pro-00000.

Para mostrar los valores más recientes de cada uno de los sensores, puede usar la función last:

select device_id, last(temperature, time)
  FROM conditions
  GROUP BY device_id;

En el resultado, verá una lista de todos los sensores y los valores pertinentes más recientes.

Para obtener los primeros valores, utilice la función first.

El ejemplo siguiente es más complejo. Mostrará el promedio de temperatura por hora y las temperaturas mínima y máxima correspondientes al sensor elegido en las últimas 24 horas:

SELECT time_bucket('1 hour', time) "hour",
trunc(avg(temperature), 2) avg_temp,
trunc(min(temperature), 2) min_temp,
trunc(max(temperature), 2) max_temp
FROM conditions
WHERE device_id = 'weather-pro-000000'
GROUP BY "hour" ORDER BY "hour" DESC LIMIT 24;

Aquí, utilizó la función time_bucket que es una versión más útil de la función date_trunc de PostgreSQL. Como resultado, verá los momentos del día en los que la temperatura sube o baja:

Output
          hour          | avg_temp | min_temp | max_temp
------------------------+----------+----------+----------
 2016-11-16 21:00:00+00 |    42.00 |    42.00 |    42.00
 2016-11-16 20:00:00+00 |    41.92 |    41.69 |    42.00
 2016-11-16 19:00:00+00 |    41.07 |    40.59 |    41.59
 2016-11-16 18:00:00+00 |    40.11 |    39.79 |    40.59
 2016-11-16 17:00:00+00 |    39.46 |    38.99 |    39.79
 2016-11-16 16:00:00+00 |    38.54 |    38.19 |    38.99
 2016-11-16 15:00:00+00 |    37.56 |    37.09 |    38.09
 2016-11-16 14:00:00+00 |    36.62 |    36.39 |    37.09
 2016-11-16 13:00:00+00 |    35.59 |    34.79 |    36.29
 2016-11-16 12:00:00+00 |    34.59 |    34.19 |    34.79
 2016-11-16 11:00:00+00 |    33.94 |    33.49 |    34.19
 2016-11-16 10:00:00+00 |    33.27 |    32.79 |    33.39
 2016-11-16 09:00:00+00 |    33.37 |    32.69 |    34.09
 2016-11-16 08:00:00+00 |    34.94 |    34.19 |    35.49
 2016-11-16 07:00:00+00 |    36.12 |    35.49 |    36.69
 2016-11-16 06:00:00+00 |    37.02 |    36.69 |    37.49
 2016-11-16 05:00:00+00 |    38.05 |    37.49 |    38.39
 2016-11-16 04:00:00+00 |    38.71 |    38.39 |    39.19
 2016-11-16 03:00:00+00 |    39.72 |    39.19 |    40.19
 2016-11-16 02:00:00+00 |    40.67 |    40.29 |    40.99
 2016-11-16 01:00:00+00 |    41.63 |    40.99 |    42.00
 2016-11-16 00:00:00+00 |    42.00 |    42.00 |    42.00
 2016-11-15 23:00:00+00 |    42.00 |    42.00 |    42.00
 2016-11-15 22:00:00+00 |    42.00 |    42.00 |    42.00
(24 rows)

Puede encontrar más funciones útiles en la documentación de TimescaleDB.

Ahora, sabrá manejar sus datos. A continuación, aprenderá a eliminar y comprimir datos innecesarios.

Paso 6: Configurar la compresión y eliminación de datos

A medida que los datos se acumulen, ocuparán cada vez más espacio en su disco duro. Para ahorrar espacio, la última versión de TimescaleDB proporciona una función de compresión de datos. Esta función no requiere ajustar la configuración del sistema de archivos y se puede utilizar para hacer que su base de datos sea más eficiente de forma rápida. Para obtener más información sobre cómo funciona esta compresión, consulte este artículo de TimescaleDB sobre la compresión.

Primero, habilite la compresión de su hipertabla:

ALTER TABLE conditions SET (
  timescaledb.compress,
  timescaledb.compress_segmentby = 'device_id'
);

Obtendrá los siguientes datos:

Output
NOTICE:  adding index _compressed_hypertable_2_device_id__ts_meta_sequence_num_idx ON _timescaledb_internal._compressed_hypertable_2 USING BTREE(device_id, _ts_meta_sequence_num)
ALTER TABLE

SELECT add_compress_chunks_policy('conditions', INTERVAL '7 days');

Puede ver las estadísticas de los datos comprimidos con el siguiente comando:

SELECT *
FROM timescaledb_information.compressed_chunk_stats;

Luego, verá una lista de fragmentos con sus estados: el estado de la compresión y el espacio que ocupan los datos comprimidos y descomprimidos en bytes.

Si no necesita almacenar datos por período prolongado, puede eliminar aquellos que sean obsoletos para liberar aún más espacio. La función especial drop_chunks se utiliza para hacerlo. Le permite eliminar fragmentos con datos anteriores al tiempo especificado:

SELECT drop_chunks(interval '24 hours', 'conditions');

Con esta consulta, se eliminarán todos los fragmentos de la hipertabla conditions que solo incluyan datos de más de un día de antigüedad.

Recibirá el siguiente resultado:

Output
              drop_chunks
----------------------------------------
 _timescaledb_internal._hyper_1_2_chunk
(1 row)

Para eliminar de forma automática datos antiguos, puede configurar una tarea de cron. Consulte nuestro tutorial si desea más información sobre cómo usarcronpara automatizar varias tareas del sistema.

Cierre la base de datos:

\q

Luego, edite su crontab con el siguiente comando, que debe ejecutarse desde el shell:

crontab -e

Ahora, añada la siguiente línea al final del archivo:

...

0 1 * * * /usr/bin/psql -h localhost -p 5432 -U postgres -d postgres -c "SELECT drop_chunks(interval '24 hours', 'conditions');" >/dev/null 2>&1

Con esta tarea se eliminarán los datos obsoletos de más de un día de antigüedad todos los días a la 1:00 a. m.

Conclusión

Con esto, habrá configurado TimescaleDB en su servidor de CentOS. También creó hipertablas e insertó datos en ellas, consultó estos últimos y comprimió y eliminó registros innecesarios. Con estos ejemplos, podrá aprovechar los beneficios claves de TimescaleDB frente a los sistemas tradicionales de gestión de bases de datos relacionales para el almacenamiento de datos de series temporales, entre los que se incluyen los siguientes:

• Mayores tasas de ingesta de datos
• Rendimiento de consultas más rápido
• Características orientadas al tiempo