Compaction de Force MergeCompatible with Milvus 3.0.x

Force Merge est conçu pour consolider les petits segments fragmentés en segments plus petits et plus grands afin d'améliorer les performances des requêtes et l'efficacité du stockage. Ce guide explique comment utiliser le compactage par fusion forcée.

Vue d'ensemble

Le compactage standard maintient la taille des segments près de la valeur configurée maxSize grâce à des fusions plusieurs à plusieurs, mais il peut toujours laisser des fragments de taille moyenne qui ne peuvent pas être fusionnés davantage sans dépasser les limites. Par exemple, comme illustré ci-dessous, si une collection comporte cinq segments de 2 Mo et que maxSize est de 3 Mo, la fusion de deux segments dépasserait la limite, de sorte que le compactage standard ne peut pas réduire davantage le nombre de segments et que la disposition fragmentée subsiste.

Forcer la fusion ajoute un paramètre target_size et permet de réorganiser les segments en fonction de la taille souhaitée dans le cadre d'une tolérance étroite lorsque cela est possible. Comme illustré ci-dessous, si la taille spécifiée pour target_size est de 4 Mo, les cinq petits segments de 2 Mo peuvent être fusionnés en un nombre réduit de segments plus grands. Cela permet de réduire le nombre excessif de segments, de prendre en charge des cibles plus grandes que les paramètres par défaut de maxSize et, lorsque la cible est très grande, de laisser le système choisir une taille de sortie et un nombre de segments pratiques pour le matériel actuel et la topologie de QueryNode.

Pour savoir quelle méthode de compactage utiliser, voir la FAQ.

R8eow3kaqhktokblcmocnvxmnee

Le compactage par fusion forcée étend l'API Compaction existante avec un paramètre target_size. Il est entièrement rétrocompatible : les appels de compactage existants sans target_size continuent de fonctionner comme auparavant.

La fusion forcée fonctionne de manière asynchrone. Elle ne bloque pas les opérations de recherche ou de requête, bien qu'elle consomme des ressources d'E/S et de mémoire pendant l'exécution.

Utiliser le compactage par fusion forcée

Conditions préalables

• Milvus version 3.0 ou ultérieure

• PyMilvus 3.0 ou version ultérieure

Configuration globale

Les paramètres de configuration suivants contrôlent le comportement de Force Merge. Définissez-les dans le fichier de configuration de Milvus ou via des variables d'environnement.

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.

Paramètre	Valeur par défaut	Description de la valeur par défaut
dataCoord.segment.maxSize	512	Taille maximale du segment par défaut en Mo. Utilisée comme cible lorsque target_size est égal à 0 ou omis. Sert également de valeur minimale autorisée pour target_size.
dataCoord.compaction.maxFullSegmentThreshold	100	Seuil du nombre de segments pour la sélection de l'algorithme. Lorsque le nombre de segments dépasse cette valeur, Milvus utilise un algorithme gourmand plus rapide pour la planification de la fusion. Algorithme standard (utilisé lorsque le nombre de segments <= dataCoord.compaction.maxFullSegmentThreshold) : produit des résultats de fusion plus optimaux mais prend plus de temps à calculer. Algorithme gourmand (utilisé lorsque le nombre de segments > dataCoord.compaction.maxFullSegmentThreshold) : achève la planification beaucoup plus rapidement au prix d'un regroupement de segments légèrement moins optimal.
dataCoord.compaction.forceMerge.datanodeMemoryFactor	4.0	La mémoire du DataNode est divisée par ce facteur pour calculer la plus grande taille de segment que le système peut autoriser. Une valeur plus élevée alloue moins de mémoire à la fusion mais en laisse plus pour les autres opérations du DataNode, ce qui améliore la stabilité du nœud. Une valeur plus faible permet des fusions plus importantes, mais augmente la pression sur la mémoire. Par exemple, avec le facteur par défaut de 4,0 et un DataNode doté d'une mémoire de 16 Go, le budget de fusion est de 4 Go. Cela signifie que la taille totale des segments fusionnés en une seule opération ne peut pas dépasser 4 Go.
dataCoord.compaction.forceMerge.querynodeMemoryFactor	4.0	La mémoire minimale du QueryNode est divisée par ce facteur. Utilisé lors du calcul automatique de la taille (target_size=max_int64) pour s'assurer que les segments fusionnés peuvent être chargés par les QueryNodes. Une valeur élevée produit des segments plus petits qui sont plus faciles à charger par les QueryNodes. Une valeur plus petite permet d'obtenir des segments plus grands, mais peut entraîner des échecs de chargement sur les nœuds de requête dont la mémoire est limitée. Par exemple, avec le facteur par défaut de 4,0 et le plus petit QueryNode disposant de 16 Go de mémoire, la taille cible auto-calculée ne dépassera pas 4 Go. Cela empêche Force Merge de produire des segments si grands que les QueryNodes ne peuvent pas les charger.

Pour appliquer les modifications ci-dessus à votre cluster Milvus, veuillez suivre les étapes des sections Configurer Milvus avec Helm et Configurer Milvus avec Milvus Operators.

Déclencher le compactage par fusion forcée

Vous déclenchez le compactage Force Merge en appelant compact() avec le paramètre target_size. Pour plus d'informations sur les paramètres, voir la section Référence des paramètres ci-dessous.

Trois modes de compactage par fusion forcée sont disponibles :

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

Les exemples suivants montrent comment utiliser chaque mode de compactage par fusion forcée.

Valeur par défaut (compactage standard)

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

Taille cible explicite

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

Calcul automatique de la taille

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

Référence des paramètres

Le tableau suivant explique les paramètres.

Paramètre	Type de paramètre	Description
collection_name	str	Obligatoire. Le nom de la collection à compacter.
target_size	int	Facultatif. La taille du segment cible en Mo. Il existe 3 options pour la valeur du paramètre : 0 ou omis: utilise la valeur configurée dataCoord.segment.maxSize (par défaut : 512 Mo). Équivalent au compactage standard. Valeur explicite: fusionne les segments pour obtenir approximativement la taille spécifiée en Mo (par exemple, 2048). Doit être supérieur ou égal à la valeur configurée dataCoord.segment.maxSize. max_int64 ((1 << 63) - 1): Calcule automatiquement la taille optimale en fonction de la distribution actuelle des segments et des ressources disponibles du nœud.

Vérifier la progression du compactage

Le compactage de Force Merge s'exécute de manière asynchrone. Utilisez l'ID du travail renvoyé pour vérifier la progression :

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

Meilleures pratiques

• N'utilisez pas le compactage par fusion forcée dans les environnements de production.

• Utilisez le mode de calcul automatique de la taille dans la plupart des cas. La définition de target_size sur max_int64 permet à Milvus d'analyser la distribution de vos segments et les ressources des nœuds pour déterminer la meilleure taille. Il s'agit de l'approche recommandée, sauf si vous avez des exigences spécifiques en matière de taille.

• Tenez compte du compromis de performance. Le compactage par fusion forcée est une opération gourmande en ressources. Elle lit, fusionne et réécrit les données des segments. Programmez-la pendant les périodes de faible trafic pour minimiser l'impact sur la latence des requêtes.

• Surveillez le nombre de segments avant et après l'opération. Utilisez get_compaction_state() et list_persistent_segments pour vérifier que le compactage a produit des segments moins nombreux et plus grands, comme prévu.

FAQ

En quoi Force Merge diffère-t-il du compactage standard ?

Ces deux types d'opérations de compactage ont des objectifs différents.

• Le compactage standard (targetSize=0 ou omis) est une méthode de nettoyage incrémentielle et la plus efficace possible.

• La fusion forcée (targetSize>0) est un chemin de reconditionnement au niveau de la collection pour produire des segments moins nombreux, plus grands et proches de la cible.

La principale différence réside dans la forme de la fusion : le compactage standard est effectivement m → 1 par tâche, tandis que la fusion forcée est m → n sur l'ensemble des entrées groupées. C'est la raison pour laquelle la fusion forcée peut résoudre des dispositions de segments que le compactage standard ne peut pas résoudre. Le tableau suivant compare les deux types d'opérations.

Dimension	Compactage standard (par défaut)	Fusion forcée
Déclenchement de l'API	targetSize=0 (ou non défini), pas de drapeau Major/L0	targetSize>0 (MB)
Objectif principal	Nettoyage progressif des fragments évidents ; maintenance de routine	Consolidation à l'échelle de la collection pour la recherche et l'équilibre
Source de la taille des segments	Fixed dataCoord.segment.maxSize (configuration du serveur)	Taille cible de l'utilisateur, puis taille de sécurité limitée par maxSafeSize
Validité des paramètres	Pas de réglage de la taille de l'utilisateur	La taille cible de l'utilisateur doit être >= dataCoord.segment.maxSize ; sinon, elle est rejetée.
Limite supérieure de sécurité	Limite de configuration uniquement	maxSafeSize = min(QueryNode mem, DataNode mem) / memory_factor (standalone non-pooling : encore divisé par deux)
Forme de la fusion	m → 1 par tâche, sortie <= configMaxSize	m → n, sorties proches de targetSize
Comportement des segments moyens	Peut être bloqué de manière permanente (par exemple, deux segments de 60 % ne peuvent pas légalement devenir un segment de 120 %).	Repack + split fonctionne ; pas de schéma "bloqué à 60%".
Capacité d'aplanissement de la collection	Limitée ; des exécutions répétées peuvent encore laisser de nombreux segments moyens.	Forte ; conçue pour réduire le nombre de segments et augmenter le taux de remplissage.
Prise en compte de la topologie	Aucune	Oui ; utilise QueryNode/replica/shard layout
Réglage du parallélisme de lecture	Aucun	Ajuste le nombre de sorties en utilisant queryNodeCount / (replicas × shards) lorsqu'il est valide
Cas d'utilisation typique	Nettoyage quotidien à forte consommation après les écritures/suppressions	Préparation du benchmark, optimisation de la recherche, alignement du parallélisme de charge
Attentes en matière d'étendue	Ne pas s'attendre à un reconditionnement complet de la collection	Destiné à un résultat de reconditionnement au niveau de la collection

Conseils de sélection :

• Choisissez le compactage standard pour un nettoyage incrémental à faible risque.

• Choisissez la fusion forcée lorsque vous souhaitez explicitement remodeler la collection en segments moins nombreux et plus grands, alignés sur le comportement de recherche et de chargement.

En quoi la fusion forcée diffère-t-elle du compactage par regroupement ?

Lecompactage par regroupement (is_clustering=True) réorganise les données au sein des segments sur la base d'une clé de regroupement afin d'améliorer l'élagage de la recherche. Force Merge (target_size=N) optimise la taille des segments sans modifier la distribution des données. Ils ont des objectifs différents et peuvent être utilisés ensemble - exécutez d'abord le compactage par regroupement pour organiser les données, puis Force Merge pour consolider les segments résultants.

Puis-je exécuter Force Merge sur une collection qui fait l'objet d'une requête ?

Oui. Force Merge s'exécute de manière asynchrone et ne bloque pas les requêtes. Cependant, elle consomme des ressources DataNode et des ressources d'E/S de disque, de sorte que la latence des requêtes peut augmenter pendant le compactage. Pour obtenir les meilleurs résultats, planifiez Force Merge pendant les périodes de faible trafic.

Que se passe-t-il si je définis une target_size inférieure à maxSize ?

La requête est rejetée avec une erreur. La taille cible doit être supérieure ou égale à la taille configurée dataCoord.segment.maxSize.