Escalabilidade e sizing¶
Esta página traz os números medidos pelo benchmark de escala, a projeção para o porte alvo
com as premissas explícitas e o dimensionamento adotado, conciliado com o que estava em
deploy/README.md.
Porte alvo¶
100 arrays (150 PB), ~200 mil volumes, 6 mil portas de storage, 30 mil portas SAN, 25 mil VMs, 1,5 mil hipervisores, 4 mil datastores, 600 pools e 400 controladoras.
Volume de pontos com os intervalos padrão (backend/tools/benchmark/scale_benchmark.py::rows_per_day):
| Origem | Séries | Intervalo | Pontos/dia |
|---|---|---|---|
| volumes (10 métricas de I/O) | 2.000.000 | 5 min | 576,0 M |
| portas de switch (9 métricas) | 270.000 | 1 min | 388,8 M |
| VMs (7 métricas) | 175.000 | 5 min | 50,4 M |
| portas de storage (5) | 30.000 | 5 min | 8,6 M |
| hipervisores + datastores (5) | 27.500 | 5 min | 7,9 M |
| arrays + pools + controladoras (12) | 13.200 | 5 min | 3,8 M |
| Total | ≈ 2,52 M séries | ≈ 1,036 × 10⁹ pontos/dia ≈ 12 mil pontos/s em média |
A chegada não é uniforme. Com os ciclos alinhados, ~2,4 M pontos chegam logo após cada fronteira de 5 min e ~270 mil a cada minuto. Se o pico de um ciclo se espalhar por ~60 s, a taxa chega a ~45 mil pontos/s, e é por esse número que o caminho de escrita deve ser dimensionado.
Resultados medidos¶
Ambiente da medição
Sandbox com 2 vCPU e 7 GB de RAM, ClickHouse embutido (chdb) no mesmo processo do benchmark, sem rede, PostgreSQL 16 local e dados sintéticos com forma realista (ciclo diário + ruído). Os números servem para ordem de grandeza e proporções. Um servidor ClickHouse dedicado com NVMe e dezenas de núcleos é substancialmente mais rápido em inserção e consulta. Não é uma medição de produção.
Comando: python backend/tools/benchmark/scale_benchmark.py --rows 50000000 --pg-dsn …
Caminho de ingestão em Python (por processo, 800 mil linhas)¶
| Etapa | Linhas/s |
|---|---|
coletor: montar PerfBatch |
2.170.182 |
| coletor: serializar em msgpack | 340.742 |
| ingestor: desserializar + montar colunas | 406.998 |
| tamanho na mensagem | 62,0 bytes/linha |
ClickHouse (chdb), 50 M linhas, 200 mil volumes × 5 métricas × 50 intervalos¶
| Medida | Valor |
|---|---|
| inserção, incluindo as 3 materialized views de rollup | 78.930 linhas/s |
tamanho em disco da tabela bruta (após OPTIMIZE FINAL) |
7,42 bytes/ponto (compressão 6,3×) |
| Consulta (melhor de 3) | Latência |
|---|---|
| top-10 por p95 de latência, 24 h, 200 mil volumes (bruto) | 512,9 ms |
| série temporal de 10 volumes (bruto) | 6,7 ms |
| indicador + sparkline (soma de IOPS por hora, todos os volumes) | 121,7 ms |
| top-10 no rollup horário | 112,6 ms |
top-20 de último valor (metrics_latest) |
54,5 ms |
| varredura da janela de 20 min dos ratings (todas as séries) | 975,5 ms |
Medição complementar do tamanho dos rollups após merge completo (1 dia de dados; mesmo gerador;
OPTIMIZE FINAL em todas as tabelas):
| Tabela | Séries a 5 min (12 pontos/h) | Séries a 1 min (60 pontos/h) |
|---|---|---|
metrics (bruto) |
6,3 bytes/ponto | 6,0 bytes/ponto |
metrics_1h |
90,5 bytes/linha (1 linha/série/hora) | 288,4 bytes/linha |
metrics_1d |
1.021 bytes/linha (1 linha/série/dia) | 1.403 bytes/linha |
metrics_latest |
14–25 bytes/série |
O estado quantileTDigest(0,95) responde pela maior parte do tamanho dos rollups (em metrics_1h,
~95 % dos bytes). Aplicar CODEC(ZSTD(3)) às colunas de estado reduziu os rollups em ~35 % no
mesmo teste (288 → 188 e 1.403 → 902 bytes/linha). Isso não está no DDL da v1.0.0.
PostgreSQL: snapshot de inventário com 200 mil volumes¶
| Medida | Valor |
|---|---|
| objetos / relações | 202.009 / 402.008 |
| primeiro snapshot (COPY + merge) | 22,6 s |
| snapshot seguinte (diff de configuração + merge) | 28,8 s |
| tamanho do banco após o teste | 402 MB (entities 126 MB, relations 174 MB, identifiers 93 MB) |
Projeção para o porte alvo¶
Caminho de escrita¶
| Componente | Necessário (alvo) | Medido | Folga | Premissa |
|---|---|---|---|---|
| ingestor (CPU Python) | 12 mil/s médio, ~45 mil/s no pico | 407 mil linhas/s por processo (só desserialização) | ~9× no pico com 1 processo | o insert pelo clickhouse-connect (HTTP + LZ4) não foi medido. O plano adota a estimativa conservadora de 40–60 mil linhas/s por réplica de deploy/README.md e 4 réplicas (160–240 mil/s, 3,5–5× o pico) |
| ClickHouse (insert + MVs) | ~45 mil/s no pico | 79 mil/s em 2 vCPU embutidos | ~1,7× já no sandbox | um servidor de 32 vCPU com NVMe tem ordens de grandeza a mais de margem. O CPU do ClickHouse no alvo é dominado por merges e consultas, não pela inserção |
| NATS JetStream | ~0,75 MB/s médio (64 GB/dia de mensagens a 62 B/linha) | — | — | buffer de 6 h (max_age) ≈ 16 GB, dentro dos 20 GiB do stream |
| PostgreSQL (inventário) | 100 snapshots/h (inventário horário), somando ~200 mil volumes | 23–29 s para um snapshot de 200 mil volumes | cada snapshot real é menor; um ingestor aplica um por vez | o tempo de aplicação deve ficar abaixo do ack_wait de 120 s do consumidor (o ingestor chama in_progress() antes de aplicar) |
Consultas¶
Com 200 mil volumes, as consultas de dashboard medidas ficam entre 7 ms e 0,5 s em 2 vCPU. A varredura dos ratings no alvo lê ~14 M pontos (20 min × 12 mil/s), ~3,5× a amostra medida, o que dá ~3–4 s por ciclo de 300 s no mesmo hardware e menos em servidor dedicado. A change detection lê apenas o rollup horário dos pares avaliados.
Disco do ClickHouse¶
Fórmula: bruto = pontos/dia × 6,7 B × raw_days, 1h = séries × 24 × B_1h × hourly_days,
1d = séries × B_1d × daily_days, com os bytes/linha medidos acima.
| Porte | Séries | Pontos/dia | 1º ano, padrões (35/365/365 efetivos) | Regime, padrões (35/400/1830) | Recomendado (35/180/730) |
|---|---|---|---|---|---|
| Pequeno (10 arrays, 2 mil portas, 2 mil VMs) | 0,24 M | 0,09 × 10⁹ | 0,33 TB | 0,72 TB | 0,31 TB |
| Médio (40 arrays, 10 mil portas, 10 mil VMs) | 0,99 M | 0,39 × 10⁹ | 1,4 TB | 3,0 TB | 1,3 TB |
| Grande (alvo) | 2,52 M | 1,04 × 10⁹ | 3,7 TB (bruto 0,24 · 1h 2,46 · 1d 0,98) | 7,8 TB (bruto 0,24 · 1h 2,70 · 1d 4,89) | 3,4 TB (bruto 0,24 · 1h 1,21 · 1d 1,95) |
Some ≥ 30 % de espaço livre para merges e backup local. O rollup diário com retenção padrão de 5 anos continua crescendo ~1 TB/ano no porte grande até atingir o regime.
Recomendação para ambientes grandes
Configure retention.hourly_days = 180 e retention.daily_days = 730 (Configurações ›
Retenção de dados) se o histórico de 5 anos não for necessário. Para reduzir mais, a
evolução indicada é aplicar CODEC(ZSTD(3)) às colunas de estado dos rollups (−35 % medido) ou
tornar o percentil opcional no rollup diário. Ambas exigem alteração de código (registrado em
Changelog).
Dimensionamento adotado¶
| Componente | Pequeno | Médio | Grande (alvo) |
|---|---|---|---|
| ClickHouse | 4 vCPU, 16 GB RAM, 0,5 TB SSD | 16 vCPU, 64 GB, 2 TB NVMe | 32 vCPU, 128 GB, 5 TB NVMe úteis com retenção recomendada (35/180/730); 10 TB para os padrões de 5 anos, ou cluster 2 shards × 2 réplicas |
| PostgreSQL | 2 vCPU, 4 GB, 20 GB | 4 vCPU, 8 GB, 50 GB | 8 vCPU, 16 GB, 100 GB SSD (shared_buffers 4 GB, max_connections 500) |
| Ingestores | 1 × (1 vCPU, 1 GB) | 2 × (2 vCPU, 2 GB) | 4 × (4 vCPU, 4 GB) |
| Engine | 2 vCPU, 2 GB | 4 vCPU, 4 GB | 8 vCPU, 16 GB |
| API | 2 workers, 2 GB | 4 workers, 4 GB | 8 workers, 8 vCPU, 8 GB |
| Coletores | 1 local | 1–2 (2 vCPU, 2 GB) | 3+ (4 vCPU, 4 GB, concorrência 64), 1 por site remoto |
| NATS | 1 vCPU, 1 GB, 20 GB | 2 vCPU, 2 GB, 60 GB | 4 vCPU, 4 GB, 60 GB SSD |
Os perfis de CPU/RAM do docker-compose.yml (médio) e do docker-compose.scale.yml (grande)
correspondem a esta tabela.
Conciliação com deploy/README.md (versão anterior)¶
| Item | Antes | Medido / projetado | Adotado | Motivo |
|---|---|---|---|---|
| bytes por ponto (bruto) | 2–4 B | 6,0–7,4 B (dados sintéticos com ruído) | 6–7 B para planejamento | medição. Métricas de erro de porta (quase sempre zero) devem comprimir melhor em dados reais, então o valor é conservador |
| 35 dias brutos (grande) | 70–140 GB | ~240 GB | ~250 GB | consequência do item anterior |
| rollups 1h + 1d (grande) | +40–120 GB | 2,7 TB + 4,9 TB no regime padrão | retenção recomendada 180/730 → ~3,2 TB | o estado do percentil TDigest custa 90–1.400 B/linha. A estimativa anterior não considerava o tamanho dos estados de agregação |
| disco ClickHouse (grande) | 2 TB NVMe | 3,7 TB no 1º ano | 5 TB (recomendado) / 10 TB (padrões) | idem |
| ingestor por réplica | 40–60 mil linhas/s | 407 mil/s só na desserialização; insert não medido | mantido 40–60 mil/s | conservador até medir o insert real no servidor |
| CPU/RAM do ClickHouse | 32 vCPU / 128 GB | insert não é o gargalo (79 mil/s em 2 vCPU) | mantido | merges contínuos, top-N sobre 200 mil séries e consultas da IA/dashboards em paralelo |
| PostgreSQL (grande) | 20–50 GB de dados | ~0,4 GB por 200 mil volumes + relações | mantido 100 GB | folga para achados, mudanças, auditoria e índices; não é o recurso crítico |
| engine | “1 réplica” | jobs exclusivos por advisory lock | ≥ 1 réplica | ver Alta disponibilidade |
| backup do ClickHouse | 110–260 GB | proporcional ao disco usado | igual ao volume de dados | backup nativo de dados já comprimidos |
deploy/README.md foi atualizado com estes valores.
Escalando além do porte alvo¶
- Ingestão: aumente as réplicas do ingestor (
QV_INGESTOR_REPLICAS,--scale ingestor=N, ou HPA no Helm). Elas compartilham os consumidores duráveis. - ClickHouse: cluster com mais shards (ClickHouse em cluster).
O sharding por
entity_iddistribui inserção e consultas. - Coleta: mais coletores, cada um com seus dispositivos. Um coletor por site/fabric.
- API: mais workers ou réplicas (sem estado).
Limite de tamanho de mensagem (v1.0.0)
PerfBatch.to_messages() divide os lotes em mensagens de até 200 mil linhas, mas o NATS
está configurado com max_payload/max_msg_size de 8 MiB, e 200 mil linhas ocupam ~13,7 MB
(medido). Um único dispositivo que produza mais de ~120 mil pontos por ciclo (por exemplo, um
array com 12 mil+ volumes × 10 métricas) terá a publicação recusada. Ver
Troubleshooting › Ingestão.