Como Instalar e Utilizar o TimescaleDB no Ubuntu 18.04

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

O gerenciamento de dados de série temporal tornou-se uma habilidade essencial com o surgimento da Internet das coisas (IoT) e da Internet das coisas industrial. 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ê montará o TimescaleDB no Ubuntu 18.04, configurando-o e aprenderá a como trabalhar com ele. Criará bancos de dados de séries temporais e fará consultas simples. Por fim, verá como se livrar dos dados desnecessários.

Pré-requisitos

Para seguir este tutorial, você vai precisar do seguinte:

• Um servidor Ubuntu 18.04 configurado seguindo nosso Guia de configuração inicial de servidor para o Ubuntu 18.04, incluindo um usuário não raiz com privilégios sudo e um firewall.
• O PostgreSQL instalado no seu servidor. Siga o Passo 1 do tutorial Como Instalar e usar o PostgreSQL no Ubuntu 18.04 para instalá-lo.

Passo 1 — Instalando o TimescaleDB

O TimescaleDB não está disponível nos repositórios padrão do Ubuntu, então, neste passo, você o instalará a partir do Arquivo de pacotes pessoais (PPA) do TimescaleDB.

Primeiro, adicione o repositório APT do Timescale:

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

Confirme essa ação clicando na chave ENTER.

Em seguida, atualize seu cache APT para atualizar suas listas de pacotes:

sudo apt update

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

sudo apt install timescaledb-postgresql-10

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, que lerá o arquivo postgresql.conf e, interativamente, sugerirá alterações.

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

sudo timescaledb-tune

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

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

Em seguida, será solicitado que você modifique a variável shared_preload_libraries para pré-carregar o módulo do TimescaleDB durante a inicialização do servidor 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]:

O shared_preload_libraries aceita uma lista separada por vírgulas de módulos como um valor, designando quais módulos o PostgreSQL deve carregar antes de inicializar o servidor de banco de dados. Fazer essa mudança adicionará o módulo timescaledb à lista.

Habilite o módulo do TimescaleDB digitando y neste prompt e pressionando ENTER:

Output
...
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, o script oferecerá o ajuste das 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.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]:

O timescaledb-tune detectará automaticamente a memória disponível dos servidores e irá calcular os valores recomendados para uma série de configurações. Por exemplo, o shared_buffers determina a quantidade de memória atribuída para o cache de dados. Por padrão, essa configuração é relativamente baixa para atender a uma gama maior de plataformas. Por isso, o timescaledb-tune sugeriu o aumento do valor de 128MB para 1994MB, permitindo um melhor aproveitamento dos recursos, por abrir mais espaço para armazenar informações em cache como consultas repetidas. A variável work_mem também foi aumentada para permitir classificações mais complicadas.

Se quiser aprender mais sobre o processo de ajustar as configurações de memória do PostgreSQL, consulte o artigo Ajustando seu servidor PostgreSQL na wiki do PostgreSQL.

Digite y para aceitar os valores:

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. Essas configurações determinam a maneira como várias CPUs conseguem fazer consultas simultâneas em paralelo aos bancos de dados e retornar mais rapidamente os dados solicitados.

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 = 13
max_parallel_workers_per_gather = 1
max_parallel_workers = 2
Is this okay? [(y)es/(s)kip/(q)uit]:

Essas configurações regulam o número de workers, 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 WAL é um método de registro no qual o PostgreSQL registra as alterações nos arquivos de dados antes das alterações serem feitas no banco de dados. Ao priorizar um registro atualizado de alterações de dados, o WAL garante que você consiga reconstruir seu banco de dados no caso de uma falha. Desta maneira, ele preserva a integridade dos dados. No entanto, as configurações padrão podem causar operações ineficientes de entrada/saída (I/O), o que reduz o desempenho na escrita. Para corrigir isso, digite e aperte y:

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

Como resultado, você receberá um arquivo de configuração pronto em /etc/postgresql/10/main/postgresql.conf.

sudo timescaledb-tune --quiet --yes

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

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

Para demonstrar isso, você usará os comandos do PostgreSQL para criar um banco de dados e, em seguida, habilitará a extensão do TimescaleDB para criar uma hipertabela, que é uma abstração de nível superior de muitas tabelas individuais. As hipertabelas são as estruturas principais com as quais você trabalhará no TimescaleDB.

Faça 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

Como mencionado anteriormente, os pontos primordiais de interação com seus dados de série temporal são as hipertabelas, que são constituídas de muitas tabelas individuais que possuem dados, chamadas de chunks.

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 com quatro colunas chamada conditions. 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. Você pode inserir dados na hipertabela usando o comando SQL padrão INSERT. 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ê verá 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, use o comando VACUUM para recuperar o espaço ainda usado pelos dados que foram excluídos.

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. Trata-se de um conjunto de dados oficial do TimescaleDB, feito para testar o 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:

wget https://timescaledata.blob.core.windows.net/datasets/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 de 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ê terminou de configurar o TimescaleDB no seu servidor Ubuntu 18.04. 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

Agora que sabe como armazenar dados de série temporal, use os dados para criar gráficos. O TimescaleDB é compatível com as ferramentas de visualização que funcionam com o PostgreSQL, como o Grafana. Você pode utilizar nosso tutorial Como Instalar e proteger o Grafana no Ubuntu 18.04 para aprender mais sobre essa ferramenta de visualização popular.