Como instalar e utilizar o TimescaleDB no CentOS 7

O autor selecionou o Computer History Museum para receber uma doação como parte do programa Write for DOnations.

Introdução

Muitos aplicativos acumulam dados para análises mais detalhadas como, por exemplo, os sistemas de monitoramento e os sistemas de coleta de dados. Com frequência, tais análises examinam o modo como os dados ou um sistema mudam com o tempo. Nestes casos, os dados são representados como uma série temporal, com cada ponto de dados acompanhado de um carimbo de data/hora. No exemplo abaixo, você pode ter uma ideia da aparência que teriam:

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

Recentemente, a importância dos dados de série temporal aumentou, graças às novas implantações da Internet das coisas (loT) e da Internet industrial das coisas (IIoT). Há um crescente número de dispositivos que coletam várias informações de séries temporais: monitores fitness, relógios inteligentes, estações meteorológicas domésticas e vários sensores, para citar alguns. Esses dispositivos coletam muitas informações e todos esses dados devem ser armazenados em algum lugar.

Na maioria dos casos, os bancos de dados relacionais clássicos são usados para armazenar dados, mas eles nem sempre se encaixam quando se trata de volumes elevados de dados da série temporal. Quando você precisa processar uma grande quantidade de dados de série temporal, os bancos de dados relacionais podem ser muito lentos. Por causa disso, foram criados os bancos de dados especialmente otimizados, chamados bancos de dados NoSQL. Eles foram criados para evitar os problemas dos banco de dados relacionais.

O TimescaleDB é um banco de dados de código aberto, otimizado para armazenar dados da série temporal. Ele é implementado como uma extensão do PostgreSQL e combina a facilidade do uso dos bancos de dados relacionais e a velocidade dos bancos de dados NoSQL. Como resultado, ele permite que você utilize o PostgreSQL para armazenar dados comerciais e dados da série temporal em um único lugar.

Ao seguir este tutorial, você configurará o TimescaleDB no CentOS 7 e aprenderá como trabalhar com ele. Você passará pela criação de bancos de dados da série temporal e pela realização de consultas simples. Por fim, verá como remover dados desnecessários.

Pré-requisitos

Para seguir este tutorial, você vai precisar de:

• Um servidor CentOS 7 configurado, de acordo com o nosso Guia de configuração inicial de servidor com o CentOS 7, incluindo um usuário não raiz com privilégios sudo e um firewall, configurado com o firewalld. Para configurar o firewalld, siga as instruções da seção “Configurando um Firewall Básico”, do tutorial Passos adicionais recomendáveis para novos servidores em CentOS 7.
• O PostgreSQL instalado no seu servidor. Siga as instruções de nosso guia sobre Como instalar e utilizar o PostgreSQL em CentOS 7 para instalá-lo e configurá-lo.

Passo 1 — Instalando o TimescaleDB

O TimescaleDB não está disponível nos repositórios de pacotes padrão do CentOS. Neste passo, você o instalará a partir do repositório do TimescaleDB de terceiros.

Primeiro, crie um novo arquivo de repositório:

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

Entre em modo de inserção, pressionando i e cole a seguinte configuração no arquivo:

[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

Quando terminar, pressione ESC para sair do modo de inserção e, depois, digite :wq e pressione ENTER para salvar e sair do arquivo. Para aprender mais sobre o editor de texto vi e seu sucessor vim, confira nosso tutorial de Instalando e usando o editor de texto Vim em um servidor em nuvem.

Agora, prossiga com a instalação. Este tutorial usa o PostgreSQL versão 11; se estiver usando uma versão diferente do PostgreSQL (9.6 ou 11, por exemplo), substitua o valor no seguinte comando e execute o comando:

sudo yum install -y timescaledb-postgresql-11

O TimescaleDB agora está instalado e pronto para ser usado. Em seguida, você irá ligá-lo e ajustar algumas das configurações associadas a ele no arquivo de configuração do PostgreSQL para otimizar o banco de dados.

Passo 2 — Configurando o TimescaleDB

O módulo TimescaleDB funciona bem com as configurações padrão do PostgreSQL. Porém,a fim de melhorar o desempenho e fazer melhor uso do processador, memória e dos recursos de disco, os desenvolvedores do TimescaleDB sugerem a configuração de certos parâmetros individuais. Isso pode ser feito automaticamente com a ferramenta timescaledb-tune ou editando manualmente o arquivo postgresql.conf do seu servidor.

Neste tutorial, você usará a ferramenta timescaledb-tune. Ela lê o arquivo postgresql.conf e faz sugestões de alterações, de modo interativo.

Execute o seguinte comando para iniciar o assistente de configuração:

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

Primeiro, será solicitado que confirme o caminho até o arquivo de configuração do PostgreSQL:

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

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

O utilitário detecta automaticamente o caminho até o arquivo de configuração. Confirme isso, digitando y:

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

Em seguida, habilite o módulo TimescaleDB, digitando y no prompt seguinte e pressionando 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

Com base nas características do seu servidor e na versão do PostgreSQL, em seguida será oferecido a você fazer ajustes em suas configurações. Pressione y para iniciar o processo de ajustes:

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]:

A ferramenta timescaledb-tune detectará automaticamente a memória disponível do servidor e calculará os valores recomendados para as configurações shared_buffers, effective_cache_size, maintenance_work_mem e work_mem. Se quiser aprender mais sobre como isso é feito, confira a página do GitHub sobre o timescaledb-tune.

Se essas configurações parecerem OK, digite y:

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

Neste ponto, se seu servidor tiver várias CPUs, você encontrará as recomendações para as configurações de paralelismo. No entanto, se tiver uma CPU, o timescaledb-tune enviará você diretamente às configurações do WAL.

Para os que têm várias CPUs, haverá recomentações 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]:

Essas configurações regulam o número de trabalhos que processam as solicitações e tarefas em segundo plano. Aprenda mais sobre essas configurações com a documentação do TimescaleDB e do PostgreSQL.

Digite y e ENTER para aceitar essas configurações:

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

Em seguida, você encontrará recomendações para o Registro prévio da escrita (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]:

O conjunto de métodos WAL preserva a integridade dos dados, mas as configurações padrão podem causar ineficiência de I/O, que reduz o desempenho na escrita. Digite y e aperte enter para otimizar essas configurações:

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

Agora, você encontrará diversas recomendações:

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]:

Todos esses parâmetros diferentes visam aumentar o desempenho. Por exemplo, os SSDs podem processar muitas solicitações simultâneas, então o melhor valor para o effective_io_concurrency pode estar na casa das centenas. É possível encontrar mais informações sobre essas opções na Documentação do PostgreSQL.

Digite y e aperte 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, você receberá um arquivo de configuração pronto em /var/lib/pgsql/11/data/postgresql.conf.

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

Para que as alterações de configuração entrem em vigor, reinicie o serviço do PostgreSQL:

sudo systemctl restart postgresql-11.service

Agora, o banco de dados está funcionando com parâmetros ideais e está preparado para trabalhar com dados de série temporal. Nos próximos passos, você tentará trabalhar com esses dados: criação de novos bancos de dados e hipertabelas e realização de operações.

Passo 3 — Criando um novo banco de dados e uma hipertabela

Com sua configuração do TimescaleDB otimizada, você está pronto para trabalhar com dados de série temporal. O TimescaleDB é implementado como uma extensão do PostgreSQL, de maneira que as operações com dados de série temporal não são muito diferentes das operações com dados relacionais. Ao mesmo tempo, o banco de dados permite que você combine livremente os dados a partir da série temporal e das tabelas relacionais no futuro.

Primeiro, você criará um novo banco de banco de dados e ativará a extensão do TimescaleDB para ele. Faça o login no seu banco de dados do PostgreSQL:

sudo -u postgres psql

Agora, crie um novo banco de dados e se conecte a ele. Este tutorial nomeará o banco de dados como timeseries:

CREATE DATABASE timeseries;
\c timeseries

Você pode encontrar informações adicionais sobre como trabalhar com o banco de dados PostgreSQL em nosso tutorial sobre Como criar, remover e gerenciar tabelas no PostgreSQL em um servidor em nuvem.

Por fim, habilite a extensão do TimescaleDB:

CREATE EXTENSION IF NOT EXISTS timescaledb CASCADE;

Você verá o seguinte resultado:

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

O principal ponto de interação com seus dados da série temporal são as hipertabelas, uma abstração de muitas tabelas individuais que mantêm os dados, chamados de partes.

Para criar uma hipertabela, inicie uma tabela simples do SQL e, em seguida, converta-a em uma hipertabela, através da função create_hypertable.

Faça uma tabela que armazenará os dados para monitorar a temperatura e a umidade em uma variedade de dispositivos ao longo do tempo:

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

Esse comando criará uma tabela chamada de conditions, com quatro colunas. A primeira coluna armazenará o carimbo de data/hora, que inclui o fuso horário e não pode ficar vazia. Em seguida, utilize a coluna de hora para transformar sua tabela em uma hipertabela, que é particionada por hora:

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

Esse comando chama a função create_hypertable(), a qual cria uma hipertabela do TimescaleDB a partir de uma tabela do PostgreSQL, substituindo a última.

Você receberá o seguinte resultado:

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

Neste passo, você criou uma nova hipertabela para armazenar os dados da série temporal. Agora, você pode preenchê-la com dados, gravando-os na hipertabela e, em seguida, executar o processo de excluir os dados.

Passo 4 — Gravando e excluindo os dados

Neste passo, você inserirá os dados usando os comandos padrão do SQL e importará grandes conjuntos de dados de fontes externas. Isso mostrará aspectos do banco de dados relacional do TimescaleDB.

Primeiro, experimente usar os comandos básicos. Os dados podem ser inseridos na hipertabela, usando o comando padrão INSERT do SQL. Digite algumas amostras de dados de temperature e humidity para o dispositivo teórico weather-pro-000000,​​​​​ utilizando o seguinte comando:

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

Você receberá o seguinte resultado:

Output
INSERT 0 1

Também é possível inserir várias linhas de dados de uma vez. Experimente o seguinte:

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

Você receberá o seguinte:

Output
INSERT 0 3

Também é possível especificar que o comando INSERT retornará alguns ou todos os dados inseridos, usando a instrução RETURNING:

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

Você verá o seguinte resultado:

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

Se quiser excluir os dados da hipertabela, use o comando SQL padrão, DELETE. Execute o seguinte para excluir qualquer dado que tenha uma temperature maior que 80 ou uma humidity maior que 50:

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

Após a operação de exclusão, é recomendável utilizar o comando VACUUM, que recuperará o espaço ainda usado pelos dados que foram deletados.

VACUUM conditions;

É possível encontrar mais informações sobre o comando VACUUM na Documentação do PostgreSQL.

Esses comandos são bons para uma entrada de dados em pequena escala, mas como os dados da série temporal geram frequentemente conjuntos de dados imensos, vindos de vários dispositivos ao mesmo tempo, é fundamental saber como inserir centenas ou milhares de linhas de uma vez. Essa tarefa poderá ser realizada rapidamente, se você preparou os dados a partir de fontes externas e de maneira estruturada como, por exemplo, em formato csv.

Para testar isso, você usará um conjunto de dados de amostra que representa os dados de temperatura e umidade de uma série de locais. Esse conjunto de dados foi criado por desenvolvedores do TimescaleDB para permitir que você teste seu banco de dados. É possível verificar mais informações sobre os conjuntos de dados de amostra na documentação do TimescaleDB.

Vamos ver como você pode importar os dados a partir do conjunto de dados amostral weather_small para o seu banco de dados. Primeiro, saia do Postgresql:

\q

Então, baixe e extraia o conjunto de dados:

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

Em seguida, importe os dados de temperatura e umidade para o seu banco de dados:

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

Tal procedimento se conecta com o banco de dados timeseries e executa o comando \COPY, que, por sua vez, copia os dados do arquivo escolhido para a hipertabela conditions. Ela executará por alguns segundos.

Quando os dados tiverem sido inseridos em sua tabela, você receberá a seguinte saída:

Output
COPY 1000000

Neste passo, você adicionou dados à hipertabela manualmente e em lotes. Em seguida, continue para realizar consultas.

Passo 5 — Consultando dados

Agora que sua tabela contém dados, é possível realizar várias consultas para analisá-los.

Para começar, faça login no banco de dados:

sudo -u postgres psql -d timeseries

Como mencionado anteriormente, você pode trabalhar com as hipertabelas usando os comandos SQL padrão. Por exemplo, para mostrar as últimas 10 entradas da hipertabela conditions, execute o seguinte comando:

SELECT * FROM conditions LIMIT 10;

Você verá o seguinte resultado:

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)

Esse comando permite ver quais dados estão no banco de dados. Como o banco de dados contém um milhão de registros, você usou o LIMIT 10 para limitar a saída a 10 entradas.

Para ver as entradas mais recentes, ordene a matriz de dados por hora, em ordem decrescente:

SELECT * FROM conditions ORDER BY time DESC LIMIT 20;

Isso dará como saída as 20 principais entradas mais recentes.

Também é possível adicionar um filtro. Por exemplo, para ver as entradas do dispositivo weather-pro-000000, execute o seguinte:

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

Neste caso, você verá os 10 pontos de dados de temperatura e umidade mais recentes, conforme registrados pelo dispositivo weather-pro-000000.

Além dos comandos SQL padrão, o TimescaleDB também fornece uma série de funções especiais que são úteis para a análise de dados da série temporal. Por exemplo, para encontrar a mediana dos valores de temperatura, utilize a seguinte consulta com a função percentile_cont:

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

Você verá o seguinte resultado:

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

Dessa maneira, você verá a temperatura mediana do período todo de observação, no local em que o sensor weather-pro-00000 está instalado.

Para mostrar os valores mais recentes de cada um dos sensores, utilize a função last:

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

Na saída, você verá uma lista de todos os sensores e valores relevantes mais recentes.

Para obter os primeiros valores, use a função first.

O exemplo a seguir é mais complexo. Ele mostrará as temperaturas médias por hora, as mínimas e as máximas do sensor escolhido, nas ú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;

Aqui, você usou a função time_bucket, que atua como uma versão mais eficaz da função date_trunc do PostgreSQL. Como resultado, você verá em quais períodos do dia a temperatura aumenta ou diminui:

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)

É possível encontrar funções mais úteis na documentação do TimescaleDB.

Agora, você sabe como manipular seus dados. Em seguida, você vai estudar sobre como excluir dados desnecessários e como comprimir dados.

Passo 6 — Configurando a compressão e a exclusão de dados

À medida que os dados se acumulam, eles irão ocupar cada vez mais espaço em seu disco rígido. Para economizar espaço, a versão mais recente do TimescaleDB fornece um recurso de compressão de dados. Este recurso não exige ajustes nas configurações do sistema de arquivos, podendo ser usado para tornar seu banco de dados mais eficiente de maneira rápida. Para obter mais informações sobre como essa compressão funciona, veja este artigo sobre Compressão do TimescaleDB.

Primeiro, habilite a compressão de sua hipertabela:

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

Você receberá os seguintes dados:

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

É possível ver as estatísticas sobre os dados comprimidos com o comando:

SELECT *
FROM timescaledb_information.compressed_chunk_stats;

Então, você verá uma lista de partes de dados com seus status respectivos: o status de compressão e quanto espaço é usado ao se descomprimir e comprimir dados - em bytes.

Se não tiver a necessidade de armazenar dados por um longo período, você pode excluir dados desatualizados para liberar ainda mais espaço. Existe uma função especial para isso, a drop_chunks. Ela permite que você exclua partes com dados mais antigos que o tempo especificado:

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

Essa consulta removerá todas as partes da hipertabela conditions que incluam apenas dados mais antigos que um dia atrás.

Você receberá o seguinte resultado:

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

Para excluir dados antigos automaticamente, configure uma tarefa cron. Consulte nosso tutorial para aprender mais sobre como usar o cron para automatizar várias tarefas do sistema.

Saia do banco de dados:

\q

Em seguida, edite seu crontab com o seguinte comando, que deve ser executado a partir do shell:

crontab -e

Agora, adicione a linha seguinte ao final do arquivo:

...

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

Esse trabalho excluirá dados obsoletos - que são mais antigos que um dia - todos os dias, à 1:00 AM.

Conclusão

Agora, você configurou o TimescaleDB em seu servidor em CentOS. Você também experimentou a criação de hipertabelas, a inserção de dados nelas, a consulta de dados, a compressão e a exclusão de registros desnecessários. Com esses exemplos, você poderá aproveitar os benefícios principais do TimescaleDB em relação aos sistemas de gerenciamento de banco de dados relacionais tradicionais para o armazenamento de dados da série temporal, incluindo:

• Taxas mais elevadas de ingestão de dados
• Desempenho de consulta mais rápido
• Recursos orientados por tempo