Cómo instalar y utilizar TimescaleDB en Ubuntu 18.04

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
...

Administrar datos en series temporales se ha convertido en una habilidad esencial con el surgimiento de la Internet de las cosas (IoT) y 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 este tutorial, configurará una TimescaleDB en Ubuntu 18.04, la ajustará y aprenderá a trabajar con ella. Creará bases de datos de series temporales y realizará consultas sencillas. Finalmente, verá la manera de eliminar los datos innecesarios.

Requisitos previos

Para este tutorial, necesitará lo siguiente:

• Un servidor de Ubuntu 18.04 configurado siguiendo nuestra Guía de configuración inicial para servidores de Ubuntu 18.04, incluidos un usuario no root con privilegios sudo y un firewall.
• PostgreSQL instalado en su servidor. Siga el paso 1 de Cómo instalar y utilizar PostgreSQL en Ubuntu 18.04 para instalarlo.

Paso 1: Instalar TimescaleDB

TimescaleDB no está disponible en los repositorios de paquetes predeterminados de Ubuntu, por lo que en este paso lo instalará desde el Personal Packages Archive (PPA) de TimescaleDB.

Primero, añada el repositorio APT de Timescale.

sudo add-apt-repository ppa:timescale/timescaledb-ppa

Confirme esta acción pulsando la tecla INTRO.

A continuación, actualice su caché de APT para actualizar sus listas de paquetes:

sudo apt update

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

sudo apt install timescaledb-postgresql-10

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 de 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.

En este tutorial, usará la herramienta timescaledb-tune, que leerá el archivo postgresql.conf y le sugerirá de forma interactiva realizar cambios.

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

sudo timescaledb-tune

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

Output
Using postgresql.conf at this path:
/etc/postgresql/10/main/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.backup201911181111

A continuación, se le solicitará cambiar la variable shared_preload_libraries para precargar el módulo TimescaleDB tras iniciar el servidor de PostgreSQL:

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

shared_preload_libraries acepta una lista separada por comas de módulos como valor y designa los módulos que PostgreSQL debería cargar antes de iniciar el servidor de la base de datos. Al realizar este cambio, se añadirá el módulo timescaledb a esa lista.

Habilite el módulo de TimescaleDB escribiendo y en este mensaje y pulsando INTRO:

Output
...
Is this okay? [(y)es/(n)o]:  y
success: shared_preload_libraries will be updated

Según las características de su servidor y la versión de PostgreSQL, la secuencia de comandos ofrecerá ajustar su configuración. 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.79 GB of available memory and 4 CPUs for PostgreSQL 10

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

timescaledb-tune detectará automáticamente la memoria disponible en el servidor y calculará los valores recomendados para varios ajustes. shared_buffers, por ejemplo, determina la cantidad de memoria asignada para almacenar los datos en caché. Por defecto, este ajuste es relativamente bajo para tener en cuenta una gama amplia de plataformas. Por ello, timescaledb-tune sugirió aumentar el valor de 128MB a 1994MB y aprovechó mejor los recursos al hacer más espacio para guardar la información almacenada en caché como consultas repetidas. La variable work_mem se aumentó también para permitir clasificaciones más complicadas.

Si desea más información sobre el proceso de ajustar la configuración de la memoria para PostgreSQL, consulte el artículo Ajustar su servidor PostgreSQL en la wiki de PostgreSQL.

Introduzca y para aceptar los valores:

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. Estos ajustes determinan la forma en que varias CPU pueden realizar consultas simultáneas en paralelo para escanear bases de datos y mostrar los datos solicitados más rápido.

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 = 13
max_parallel_workers_per_gather = 1
max_parallel_workers = 2
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 es un método de registro en el cual PostgreSQL registra cambios aplicados a archivos de datos antes de que se realicen cambios en la base de datos. Al priorizar un registro actualizado de cambios de datos, WAL garantiza que pueda volver a construir su base de datos ante un bloqueo. De esta forma, conserva la integridad de los datos. Sin embargo, los ajustes predeterminados pueden generar operaciones de entrada y salida (E/S) ineficaces que ralentizan el rendimiento de escritura. Para solucionar esto,escriba e introduzca y:

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: /etc/postgresql/10/main/postgresql.conf

Como resultado, obtendrá un archivo de configuración ya preparado en /etc/postgresql/10/main/postgresql.conf​​​​​.

sudo timescaledb-tune --quiet --yes

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

sudo systemctl restart postgresql.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.

Para demostrar esto, usará los comandos de PostgreSQL a fin de crear una base de datos y luego habilitará la extensión TimescaleDB para crear una hipertabla, que es una abastracción de nivel más alto de muchas tablas individuales. Las hypertables son las estructuras principales con las que trabajará en TimescaleDB.

Inicie sesión en su base de datos 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

Como mencionamos antes, los principales puntos de interacción con sus datos de serie de tiempo son las hypertables, que constan de muchas tablas individuales llamadas 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
);

Con este comando, se crea 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 ejecutar 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. Puede insertar datos en la hipertabla usando el comando SQL estándar INSERT. Ingrese algunos datos de temperature y humidity de ejemplo para el dispositivo teórico weather-pro-000000 usando el siguiente comando:

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

Verá 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;

Tras la operación de eliminación, utilice el comando VACUUM para recuperar el 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. Este es un conjunto de datos oficial de TimescaleDB preparado para 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:

wget https://timescaledata.blob.core.windows.net/datasets/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 usar cron para 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

De esta manera, habrá configurado TimescaleDB en su servidor de Ubuntu 18.04. 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

Ahora que sabe guardar datos de series temporales, puede usarlos para crear gráficos. TimescaleDB es compatible con herramientas de visualización que funcionan con PostgreSQL, como Grafana. Puede recurrir a nuestro tutorial Cómo instalar y proteger Grafana en Ubuntu 18.04 para obtener más información sobre esta popular herramienta de visualización.