Compactação do Force MergeCompatible with Milvus 3.0.x

O Force Merge foi projetado para consolidar segmentos pequenos e fragmentados em segmentos menores e maiores para melhorar o desempenho da consulta e a eficiência do armazenamento. Este guia explica como usar a compactação de mesclagem forçada.

Visão geral

A compactação padrão mantém os tamanhos de segmento próximos aos configurados maxSize por meio de mesclagens de muitos para um, mas ainda pode deixar fragmentos de tamanho médio que não podem ser mesclados ainda mais sem exceder os limites. Por exemplo, conforme ilustrado abaixo, se uma coleção tiver cinco segmentos de 2 MB e maxSize for de 3 MB, a mesclagem de quaisquer dois segmentos excederia o limite, de modo que a compactação padrão não pode reduzir ainda mais a contagem de segmentos e o layout fragmentado permanece.

Forçar mesclagem adiciona um parâmetro target_size e suporta a reorganização dos segmentos em direção ao tamanho desejado dentro de uma tolerância estreita quando possível. Conforme ilustrado abaixo, se o target_size especificado for 4 MB, os cinco segmentos pequenos de 2 MB poderão ser mesclados em menos segmentos maiores. Isso reduz o excesso de contagens de segmentos, suporta destinos maiores do que as configurações padrão do maxSize e, quando o destino é muito grande, permite que o sistema escolha um tamanho de saída prático e uma contagem de segmentos para o hardware atual e a topologia do QueryNode.

Para entender qual método de compactação deve ser usado, consulte FAQ.

R8eow3kaqhktokblcmocnvxmnee

A compactação de mesclagem forçada estende a API Compaction API existente com um parâmetro target_size. É totalmente compatível com as versões anteriores: as chamadas de compactação existentes sem target_size continuam a funcionar como antes.

A compactação forçada funciona de forma assíncrona. Não bloqueia as operações de pesquisa ou consulta, embora consuma recursos de E/S e memória durante a execução.

Usar a compactação Force Merge

Pré-requisitos

• Milvus versão 3.0 ou posterior

• PyMilvus 3.0 ou posterior

Configuração global

Os seguintes parâmetros de configuração controlam o comportamento do Force Merge. Defina-os no arquivo de configuração do Milvus ou através de variáveis de ambiente.

dataCoord:
  segment:
    maxSize: 512         # Default segment max size (MB).
                         # Used when target_size is 0 or omitted.
  compaction:
    maxFullSegmentThreshold: 100
                         # When segment count exceeds this threshold,
                         # a faster greedy algorithm is used instead
                         # of the standard merge algorithm.
    forceMerge:
      datanodeMemoryFactor: 4.0
                         # DataNode memory divided by this factor
                         # determines the the largest segment
                         # size the system can allow.
      querynodeMemoryFactor: 4.0
                         # Minimum QueryNode memory divided by this
                         # factor. Used in automatic size calculation
                         # to ensure merged segments can be loaded.

Parâmetro	Valor Padrão	Descrição
dataCoord.segment.maxSize	512	Tamanho máximo do segmento padrão em MB. Utilizado como alvo quando target_size é 0 ou omitido. Também serve como o valor mínimo permitido para target_size explícito.
dataCoord.compaction.maxFullSegmentThreshold	100	Limite de contagem de segmentos para a seleção do algoritmo. Quando o número de segmentos excede este valor, o Milvus utiliza um algoritmo guloso mais rápido para o planeamento da fusão. Algoritmo padrão (utilizado quando a contagem de segmentos é <= dataCoord.compaction.maxFullSegmentThreshold): produz resultados de fusão mais optimizados, mas demora mais tempo a calcular. Algoritmo guloso (utilizado quando a contagem de segmentos > dataCoord.compaction.maxFullSegmentThreshold): completa o planeamento muito mais rapidamente à custa de um agrupamento de segmentos ligeiramente menos optimizado.
dataCoord.compaction.forceMerge.datanodeMemoryFactor	4.0	A memória do DataNode é dividida por esse fator para calcular o maior tamanho de segmento que o sistema pode permitir. Um valor maior aloca menos memória para a fusão, mas deixa mais para outras operações do DataNode, melhorando a estabilidade do nó. Um valor menor permite fusões maiores, mas aumenta a pressão da memória. Por exemplo, com o fator padrão de 4,0 e um DataNode com 16 GB de memória, o orçamento de mesclagem é de 4 GB. Isso significa que o tamanho total dos segmentos que estão sendo mesclados em uma única operação não pode exceder 4 GB.
dataCoord.compaction.forceMerge.querynodeMemoryFactor	4.0	A memória mínima do QueryNode é dividida por esse fator. Usado durante o cálculo automático de tamanho (target_size=max_int64) para garantir que os segmentos mesclados possam ser carregados pelos QueryNodes. Um valor maior produz segmentos mais pequenos que são mais fáceis de carregar pelos QueryNodes. Um valor menor permite segmentos maiores, mas pode causar falhas de carregamento em QueryNodes com restrições de memória. Por exemplo, com o fator padrão de 4,0 e o menor QueryNode com 16 GB de memória, o tamanho de destino calculado automaticamente não excederá 4 GB. Isso evita que o Force Merge produza segmentos tão grandes que os QueryNodes não possam carregá-los.

Para aplicar as alterações acima ao seu cluster Milvus, siga as etapas em Configure Milvus with Helm e Configure Milvus with Milvus Operators.

Acionar a compactação Force Merge

Você aciona a compactação Force Merge chamando compact() com o parâmetro target_size. Para obter detalhes sobre o parâmetro, consulte Referência do parâmetro abaixo.

Estão disponíveis três modos de compactação Force Merge:

compact("my_collection", target_size=?)
│
├─ Mode 1: target_size = 0 (or omitted)
│  Uses config maxSize (default 512 MB)
│  Equivalent to standard compaction
│
├─ Mode 2: target_size = 2048
│  Merges segments to ~2 GB each
│  Must be >= config maxSize
│
└─ Mode 3: target_size = max_int64
   Auto-calculates optimal size based on
   segment distribution and node memory

A seguir estão exemplos que mostram como usar cada modo de compactação de mesclagem forçada.

Padrão (compactação padrão)

from pymilvus import MilvusClient

client = MilvusClient(
    uri="http://localhost:19530",
    token="root:Milvus"
)

# Standard compaction — uses config maxSize (default 512 MB)
job_id = client.compact("target_collection")

Tamanho alvo explícito

# Merge segments to approximately 2 GB each
job_id = client.compact(
    "target_collection",
    target_size="2048"  # The unit is MB
)

Cálculo automático do tamanho

# Let Milvus determine the optimal segment size
max_int64 = (1 << 63) - 1
job_id = client.compact(
    "target_collection",
    target_size=max_int64
)

Referência dos parâmetros

A tabela seguinte explica os parâmetros.

Parâmetro	Tipo de parâmetro	Descrição
collection_name	str	Obrigatório. O nome da coleção a compactar.
target_size	int	Opcional. O tamanho do segmento de destino em MB. Há 3 opções para o valor do parâmetro: 0 ou omitido: Usa o dataCoord.segment.maxSize configurado (padrão: 512 MB). Equivalente à compactação padrão. Valor explícito: mescla segmentos com aproximadamente o tamanho especificado em MB (por exemplo, 2048). Deve ser maior ou igual ao configurado dataCoord.segment.maxSize. max_int64 ((1 << 63) - 1): Calcula automaticamente o tamanho ideal com base na distribuição atual do segmento e nos recursos disponíveis do nó.

Verificar o progresso da compactação

A compactação do Force Merge é executada de forma assíncrona. Use a ID do trabalho retornada para verificar o progresso:

# Check compaction state
state = client.get_compaction_state(job_id)
print(f"State: {state}")

Práticas recomendadas

• Não use a compactação de mesclagem forçada em ambientes de produção.

• Use o modo de cálculo automático de tamanho para a maioria dos casos. Definir target_size como max_int64 permite que o Milvus analise a distribuição do segmento e os recursos do nó para determinar o melhor tamanho. Essa é a abordagem recomendada, a menos que você tenha requisitos de tamanho específicos.

• Considere a troca de desempenho. A compactação Force Merge é uma operação que consome muitos recursos. Ela lê, mescla e reescreve os dados do segmento. Programe-a durante períodos de baixo tráfego para minimizar o impacto na latência da consulta.

• Monitore a contagem de segmentos antes e depois. Use get_compaction_state() e list_persistent_segments para verificar se a compactação produziu menos segmentos maiores, conforme esperado.

PERGUNTAS FREQUENTES

Qual é a diferença entre Force Merge e compactação padrão?

Esses dois tipos de operações de compactação têm finalidades diferentes.

• A compactação padrão (targetSize=0 ou omitida) é um caminho de limpeza incremental e de melhor esforço.

• Force merge (targetSize>0) é um caminho de reempacotamento no nível da coleção para produzir menos segmentos, maiores e próximos ao alvo.

A diferença chave é a forma da mesclagem: a compactação padrão é efetivamente m → 1 por tarefa, enquanto a mesclagem forçada é m → n através de entradas agrupadas. É por isso que o force merge pode resolver layouts de segmentos que a compactação padrão não pode. A tabela a seguir compara os dois tipos de operações.

Dimensão	Compactação padrão (padrão)	Forçar mesclagem
Acionador de API	targetSize=0 (ou não definido), sem sinalizador Major/L0	targetSize>0 (MB)
Objetivo principal	Limpeza incremental de fragmentos óbvios; manutenção de rotina	Consolidação de toda a coleção para pesquisa e equilíbrio
Fonte do tamanho do segmento	DataCoord.segment.maxSize fixo (configuração do servidor)	TargetSize do utilizador, depois fixado com segurança por maxSafeSize
Validade do parâmetro	Sem ajuste de tamanho do utilizador	User targetSize deve ser >= dataCoord.segment.maxSize; caso contrário, rejeitado
Limite superior de segurança	Apenas limite de configuração	maxSafeSize = min(QueryNode mem, DataNode mem) / memory_factor (standalone non-pooling: mais metade)
Forma da fusão	m → 1 por tarefa, saída <= configMaxSize	m → n, saídas próximas a targetSize
Comportamento do segmento médio	Pode ficar preso permanentemente (por exemplo, dois segmentos de 60% não podem legalmente se tornar um segmento de 120%)	Reempacotar + dividir funciona; nenhum padrão "preso em 60%"
Capacidade de achatamento da coleção	Limitada; execuções repetidas podem ainda deixar muitos segmentos médios	Forte; concebido para reduzir a contagem de segmentos e aumentar a plenitude
Conhecimento da topologia	Nenhum	Sim; utiliza QueryNode/replica/shard layout
Ajuste do paralelismo do caminho de leitura	Nenhum	Ajusta a contagem de saída usando queryNodeCount / (réplicas × shards) quando válido
Caso de utilização típico	Limpeza diária de alta rotatividade após gravações/exclusões	Preparação de benchmark, otimização de pesquisa, alinhamento de paralelismo de carga
Expectativa de alcance	Não se espera um reempacotamento da coleção completa	Destinado a resultados de reempacotamento ao nível da coleção

Orientação de seleção:

• Escolha a compactação padrão para uma limpeza incremental e de baixo risco.

• Escolha a compactação forçada quando desejar explicitamente remodelar a coleção em segmentos menores e maiores, alinhados com o comportamento de pesquisa e carregamento.

Qual é a diferença entre o Force Merge e a compactação de clustering?

A compactaçãode clustering (is_clustering=True) reorganiza os dados dentro dos segmentos com base em uma chave de clustering para melhorar a poda de pesquisa. O Force Merge (target_size=N) optimiza os tamanhos dos segmentos sem alterar a distribuição dos dados. Eles têm finalidades diferentes e podem ser usados juntos - execute a compactação de clustering primeiro para organizar os dados e, em seguida, Force Merge para consolidar os segmentos resultantes.

Posso executar o Force Merge em uma coleção que está sendo consultada?

Sim. O Force Merge é executado de forma assíncrona e não bloqueia as consultas. No entanto, ele consome recursos de E/S do DataNode e do disco, de modo que a latência da consulta pode aumentar durante a compactação. Programe o Force Merge durante períodos de baixo tráfego para obter melhores resultados.

O que acontece se eu definir um target_size menor que maxSize?

A solicitação é rejeitada com um erro. O tamanho de destino deve ser maior ou igual ao tamanho configurado dataCoord.segment.maxSize.