Dépannage d'un ralentissement de la recherche après la mise à jour de Milvus : leçons de l'équipe WPS

  • Engineering
March 18, 2026
the WPS engineering team

Ce billet a été rédigé par l'équipe d'ingénieurs WPS de Kingsoft Office Software, qui utilise Milvus dans un système de recommandation. Lors de leur mise à jour de Milvus 2.2.16 à 2.5.16, la latence de recherche a augmenté de 3 à 5 fois. Cet article explique comment ils ont étudié le problème et l'ont résolu, et peut être utile à d'autres membres de la communauté qui prévoient une mise à niveau similaire.

Pourquoi nous avons mis à jour Milvus

Nous faisons partie de l'équipe d'ingénieurs de WPS qui développe des logiciels de productivité, et nous utilisons Milvus comme moteur de recherche vectoriel derrière la recherche de similarité en temps réel dans notre système de recommandation en ligne. Notre cluster de production stockait des dizaines de millions de vecteurs, avec une dimension moyenne de 768. Les données étaient servies par 16 QueryNodes, et chaque pod était configuré avec des limites de 16 cœurs de CPU et 48 Go de mémoire.

Lors de l'exécution de Milvus 2.2.16, nous avons rencontré un grave problème de stabilité qui affectait déjà l'entreprise. En cas de forte concurrence des requêtes, planparserv2.HandleCompare pouvait provoquer une exception de pointeur nul, ce qui entraînait une panique du composant Proxy et des redémarrages fréquents. Ce bogue était très facile à déclencher dans des scénarios de forte concurrence et affectait directement la disponibilité de notre service de recommandation en ligne.

Vous trouverez ci-dessous le journal des erreurs du Proxy et la trace de pile de l'incident :

[2025/12/23 10:43:13.581 +00:00] [ERROR] [concurrency/pool_option.go:53] ["Conc pool panicked"]
[panic="runtime error: invalid memory address or nil pointer dereference"]
[stack="...
github.com/milvus-io/milvus/internal/parser/planparserv2.HandleCompare
  /go/src/github.com/milvus-io/milvus/internal/parser/planparserv2/utils.go:331
github.com/milvus-io/milvus/internal/parser/planparserv2.(*ParserVisitor).VisitEquality
  /go/src/github.com/milvus-io/milvus/internal/parser/planparserv2/parser_visitor.go:345
...
github.com/milvus-io/milvus/internal/proxy.(*queryTask).PreExecute
  /go/src/github.com/milvus-io/milvus/internal/proxy/task_query.go:271
github.com/milvus-io/milvus/internal/proxy.(*taskScheduler).processTask
  /go/src/github.com/milvus-io/milvus/internal/proxy/task_scheduler.go:455
..."]

panic: runtime error: invalid memory address or nil pointer dereference [recovered] panic: runtime error: invalid memory address or nil pointer dereference [signal SIGSEGV: segmentation violation code=0x1 addr=0x8 pc=0x2f1a02a]

goroutine 989 [running]: github.com/milvus-io/milvus/internal/parser/planparserv2.HandleCompare(…) /go/src/github.com/milvus-io/milvus/internal/parser/planparserv2/utils.go:331 +0x2a github.com/milvus-io/milvus/internal/parser/planparserv2.(*ParserVisitor).VisitEquality(…) /go/src/github.com/milvus-io/milvus/internal/parser/planparserv2/parser_visitor.go:345 +0x7e5

Ce que montre la trace de pile: La panique s'est produite pendant le prétraitement de la requête dans Proxy, à l'intérieur de queryTask.PreExecute. Le chemin d'appel était le suivant :

taskScheduler.processTaskqueryTask.PreExecuteplanparserv2.CreateRetrievePlanplanparserv2.HandleCompare

L'incident s'est produit lorsque HandleCompare a tenté d'accéder à une mémoire non valide à l'adresse 0x8, ce qui a déclenché un SIGSEGV et entraîné l'interruption du processus Proxy.

Pour éliminer complètement ce risque de stabilité, nous avons décidé de mettre à niveau le cluster de Milvus 2.2.16 à 2.5.16.

Sauvegarde des données avec milvus-backup avant la mise à niveau

Avant de toucher au cluster de production, nous avons tout sauvegardé à l'aide de l'outil officiel milvus-backup. Il prend en charge la sauvegarde et la restauration au sein d'un même cluster, entre clusters et entre versions de Milvus.

Vérification de la compatibilité des versions

milvus-backup a deux règles de version pour les restaurations inter-version:

  1. Le cluster cible doit exécuter la même version de Milvus ou une version plus récente. Une sauvegarde de la version 2.2 peut être chargée dans la version 2.5, mais pas l'inverse.

  2. La cible doit être au moins Milvus 2.4. Les cibles de restauration plus anciennes ne sont pas prises en charge.

Notre chemin (sauvegarde à partir de la version 2.2.16, chargement dans la version 2.5.16) satisfait aux deux règles.

Sauvegarde de ↓ \NRestauration vers →2.42.52.6
2.2
2.3
2.4
2.5
2.6

Fonctionnement de Milvus-Backup

Milvus Backup facilite la sauvegarde et la restauration des métadonnées, des segments et des données dans les instances Milvus. Il fournit des interfaces vers le nord, telles qu'une CLI, une API et un module Go basé sur gRPC, pour une manipulation flexible des processus de sauvegarde et de restauration.

Milvus Backup lit les métadonnées et les segments de la collection à partir de l'instance Milvus source pour créer une sauvegarde. Il copie ensuite les données de collecte à partir du chemin racine de l'instance Milvus source et les enregistre dans le chemin racine de la sauvegarde.

Pour restaurer à partir d'une sauvegarde, Milvus Backup crée une nouvelle collection dans l'instance Milvus cible en fonction des métadonnées de la collection et des informations sur les segments dans la sauvegarde. Il copie ensuite les données de sauvegarde du chemin racine de la sauvegarde vers le chemin racine de l'instance cible.

Exécution de la sauvegarde

Nous avons préparé un fichier de configuration dédié, configs/backup.yaml. Les principaux champs sont indiqués ci-dessous, les valeurs sensibles ayant été supprimées :

milvus:
  address: 1.1.1.1  # Source Milvus address
  port: 19530  # Source Milvus port
  user: root  # Source Milvus username (must have backup permissions)
  password: <PASS> # Source Milvus user password

etcd: endpoints: “2.2.2.1:2379,2.2.2.2:2379,2.2.2.3:2379” # Endpoints of the etcd cluster connected to Milvus rootPath: “by-dev” # Prefix of Milvus metadata in etcd. If not modified, the default is by-dev. It is recommended to check etcd before proceeding.

minio: # Source Milvus object storage bucket configuration storageType: “aliyun” # support storage type: local, minio, s3, aws, gcp, ali(aliyun), azure, tc(tencent), gcpnative address: ks3-cn-beijing-internal.ksyuncs.com # Address of MinIO/S3 port: 443 # Port of MinIO/S3 accessKeyID: object storage AK>
secretAccessKey: object storage SK> useSSL: true bucketName: rootPath: “file” # Root directory prefix under the source object storage bucket where the current Milvus data is stored. If Milvus is installed using Helm Chart, the default prefix is file. It is recommended to log in to the object storage and verify before proceeding.

# Object storage bucket configuration for storing backup data backupStorageType: “aliyun” # support storage type: local, minio, s3, aws, gcp, ali(aliyun), azure, tc(tencent) backupAddress: ks3-cn-beijing-internal.ksyuncs.com # Address of MinIO/S3 backupPort: 443 # Port of MinIO/S3 backupAccessKeyID: backupSecretAccessKey: backupBucketName: backupRootPath: “backup” # Root path to store backup data. Backup data will be stored in backupBucketName/backupRootPath backupUseSSL: true # Access MinIO/S3 with SSL crossStorage: “true” # Must be set to true when performing cross-storage backup

Nous avons ensuite exécuté cette commande :

# Create a backup using milvus-backup
./milvus-backup create --config configs/backup.yaml -n backup_v2216

milvus-backup La sauvegarde à chaud prend en charge la sauvegarde à chaud, de sorte qu'elle n'a généralement que peu d'impact sur le trafic en ligne. Il est préférable d'exécuter la sauvegarde pendant les heures creuses afin d'éviter la saturation des ressources.

Vérification de la sauvegarde

Une fois la sauvegarde terminée, nous avons vérifié qu'elle était complète et utilisable. Nous avons principalement vérifié si le nombre de collections et de segments dans la sauvegarde correspondait à ceux du cluster source.

./milvus-backup list --config configs/backup.yaml
# View backup details and confirm the number of Collections and Segments
./milvus-backup get --config configs/backup.yaml -n backup_v2216

Comme ils correspondaient, nous sommes passés à la mise à niveau.

Mise à jour avec Helm Chart

Le saut de trois versions majeures (2.2 → 2.5) avec des dizaines de millions de vecteurs rendait une mise à niveau sur place trop risquée. Nous avons donc construit un nouveau cluster et y avons migré les données. L'ancien cluster est resté en ligne pour le retour en arrière.

Déploiement du nouveau cluster

Nous avons déployé le nouveau cluster Milvus 2.5.16 avec Helm :

# Add the Milvus Helm repository
: helm repo add milvus https://zilliztech.github.io/milvus-helm/
helm repo update  
# Check the Helm chart version corresponding to the target Milvus version
: helm search repo milvus/milvus -l | grep 2.5.16
milvus/milvus        4.2.58               2.5.16                    Milvus is an open-source vector database built ...

# Deploy the new version cluster (with mmap disabled) helm install milvus-v25 milvus/milvus
–namespace milvus-new
–values values-v25.yaml
–version 4.2.58
–wait

Changements de configuration clés (values-v25.yaml)

Pour que la comparaison des performances soit équitable, nous avons fait en sorte que le nouveau cluster soit aussi similaire que possible à l'ancien. Nous n'avons modifié que quelques paramètres importants pour cette charge de travail :

  • Désactiver Mmap (mmap.enabled: false) : Notre charge de travail de recommandation est sensible à la latence. Si Mmap est activé, certaines données peuvent être lues sur le disque lorsque cela est nécessaire, ce qui peut ajouter un délai d'E/S sur le disque et provoquer des pics de latence. Nous l'avons désactivé pour que les données restent entièrement en mémoire et que la latence des requêtes soit plus stable.

  • Nombre de QueryNodes : 16, comme dans l'ancien cluster.

  • Limites de ressources : chaque Pod dispose toujours de 16 cœurs de CPU, comme dans l'ancien cluster.

Conseils pour les mises à niveau de versions majeures :

  • Construisez un nouveau cluster au lieu de procéder à une mise à niveau sur place. Vous évitez ainsi les risques liés à la compatibilité des métadonnées et conservez un chemin de retour en arrière propre.

  • Vérifiez votre sauvegarde avant de procéder à la migration. Une fois que les données sont au format de la nouvelle version, il est difficile de revenir en arrière.

  • Maintenez les deux clusters en fonctionnement pendant le basculement. Déplacez progressivement le trafic et ne mettez l'ancien cluster hors service qu'après une vérification complète.

Migration des données après la mise à niveau avec Milvus - Restauration de la sauvegarde

Nous avons utilisé milvus-backup restore pour charger la sauvegarde dans le nouveau cluster. Dans la terminologie de milvus-backup, "restaurer" signifie "charger les données de sauvegarde dans un cluster cible". La cible doit exécuter la même version de Milvus ou une version plus récente. Ainsi, malgré le nom, les restaurations font toujours avancer les données.

Exécution de la restauration

Le fichier de configuration de la restauration, configs/restore.yaml, devait pointer vers le nouveau cluster et ses paramètres de stockage. Les champs principaux ressemblent à ceci :

# Restore target Milvus connection information
milvus:
  address: 1.1.1.1  # Milvus address
  port: 19530  # Milvus port
  user: root  # Milvus username (must have restore permissions)
  password: <PASS> # Milvus user password  
  etcd:
    endpoints: "2.2.2.1:2379,2.2.2.2:2379,2.2.2.3:2379" # Endpoints of the etcd cluster connected to the target Milvus
    rootPath: "by-dev"  # Prefix of Milvus metadata in etcd. If not modified, the default is by-dev. It is recommended to check etcd before proceeding.

minio: # Target Milvus object storage bucket configuration storageType: “aliyun” # support storage type: local, minio, s3, aws, gcp, ali(aliyun), azure, tc(tencent), gcpnative address: ks3-cn-beijing-internal.ksyuncs.com # Address of MinIO/S3 port: 443 # Port of MinIO/S3 accessKeyID:
secretAccessKey: useSSL: true bucketName: ” rootPath: “file” # Root directory prefix under the object storage bucket where the current Milvus data is stored. If Milvus is installed using Helm Chart, the default prefix is file. It is recommended to log in to the object storage and verify before proceeding.

# Object storage bucket configuration for storing backup data backupStorageType: “aliyun” # support storage type: local, minio, s3, aws, gcp, ali(aliyun), azure, tc(tencent) backupAddress: ks3-cn-beijing-internal.ksyuncs.com # Address of MinIO/S3 backupPort: 443 # Port of MinIO/S3 backupAccessKeyID: backupSecretAccessKey: backupBucketName: backupRootPath: “backup” # Root path to store backup data. Backup data will be stored in backupBucketName/backupRootPath backupUseSSL: true # Access MinIO/S3 with SSL crossStorage: “true” # Must be set to true when performing cross-storage backup

Nous avons ensuite exécuté :

./milvus-backup restore --config configs/restore.yaml -n backup_v2216 --rebuild_index

restore.yaml nécessite les informations de connexion Milvus et MinIO du nouveau cluster afin que les données restaurées soient écrites dans le stockage du nouveau cluster.

Vérifications après la restauration

Une fois la restauration terminée, nous avons vérifié quatre éléments pour nous assurer que la migration était correcte :

  • Schéma. Le schéma de la collection dans le nouveau cluster devait correspondre exactement à l'ancien, y compris les définitions des champs et les dimensions des vecteurs.

  • Nombre total de lignes. Nous avons comparé le nombre total d'entités dans l'ancien et le nouveau cluster pour nous assurer qu'aucune donnée n'avait été perdue.

  • Statut de l'index. Nous avons vérifié que tous les index avaient fini d'être construits et que leur état était défini sur Finished.

  • Résultats des requêtes. Nous avons exécuté les mêmes requêtes sur les deux clusters et comparé les identifiants et les scores de distance renvoyés pour nous assurer que les résultats correspondaient.

Déplacement progressif du trafic et surprise en matière de latence

Nous avons transféré le trafic de production vers le nouveau cluster par étapes :

PhasePart du traficDurée du transfertCe que nous avons observé
Phase 15%24 heuresLatence des requêtes P99, taux d'erreur et précision des résultats
Phase 225%48 heuresTemps de latence des requêtes P99/P95, QPS, utilisation du CPU
Phase 350%48 heuresMesures de bout en bout, utilisation des ressources
Phase 4100%Surveillance continueStabilité globale des mesures

Nous avons maintenu l'ancien cluster en fonctionnement pendant toute la durée de l'opération pour un retour en arrière instantané.

Au cours de ce déploiement, nous avons repéré le problème : la latence de recherche sur le nouveau cluster v2.5.16 était 3 à 5 fois plus élevée que sur l'ancien cluster v2.2.16.

Trouver la cause du ralentissement de la recherche

Étape 1 : Vérifier l'utilisation globale du processeur

Nous avons commencé par vérifier l'utilisation du CPU par composant afin de déterminer si le cluster manquait de ressources.

ComposantUtilisation du CPU (cœurs)Analyse
QueryNode10.1La limite étant de 16 cœurs, l'utilisation a été d'environ 63%. Pas entièrement utilisé
Proxy0.21Très faible
MixCoord0.11Très faible
DataNode0.14Très faible
IndexNode0.02Très faible

Cela montre que QueryNode dispose toujours de suffisamment de CPU. Le ralentissement n'est donc pas dû à une pénurie globale de CPU.

Étape 2 : Vérifier l'équilibre de QueryNode

Le CPU total semblait correct, mais les pods QueryNode individuels présentaient un déséquilibre évident:

QueryNode PodUtilisation du CPU (dernière)Utilisation du CPU (Max)
querynode-pod-18.38%9.91%
querynode-pod-25.34%6.85%
querynode-pod-34.37%6.73%
querynode-pod-44.26%5.89%
querynode-pod-53.39%4.82%
querynode-pod-63.97%4.56%
querynode-pod-72.65%4.46%
querynode-pod-82.01%3.84%
querynode-pod-93.68%3.69%

Pod-1 a utilisé près de 5 fois plus de CPU que pod-8. C'est un problème car Milvus répartit une requête sur tous les QueryNodes et attend que le plus lent termine. Quelques pods surchargés ralentissaient chaque recherche.

Étape 3 : comparaison de la répartition des segments

Une charge inégale indique généralement une distribution inégale des données. Nous avons donc comparé la disposition des segments entre les anciens et les nouveaux clusters.

Disposition des segments v2.2.16 (13 segments au total)

Nombre de lignesNombre de segmentsÉtat
740,000 ~ 745,00012Scellé
533,6301Scellé

L'ancien cluster était assez homogène. Il ne comportait que 13 segments, et la plupart d'entre eux contenaient environ 740 000 lignes.

Disposition des segments de la version 2.5.16 (21 segments au total)

Nombre de lignesNombre de segmentsÉtat
680,000 ~ 685,0004Scellé
560,000 ~ 682,5505Scellé
421,575 ~ 481,8004Scellé
358,575 ~ 399,7254Scellé
379,650 ~ 461,7254Scellé

Le nouveau cluster est très différent. Il comportait 21 segments (60 % de plus), dont la taille variait : certains contenaient ~685k lignes, d'autres à peine 350k. La restauration a dispersé les données de manière inégale.

Origine du problème

Nous avons remonté le problème jusqu'à notre commande de restauration initiale :

./milvus-backup restore --config configs/restore.yaml -n backup_v2216 \
  --rebuild_index \
  --use_v2_restore \
  --drop_exist_collection \
  --drop_exist_index

Le drapeau --use_v2_restore active le mode de restauration par fusion de segments, qui regroupe plusieurs segments en un seul travail de restauration. Ce mode est conçu pour accélérer les restaurations lorsque vous avez de nombreux petits segments.

Mais dans notre restauration inter-version (2.2 → 2.5), la logique v2 a reconstruit les segments différemment du cluster d'origine : elle a divisé les gros segments en segments plus petits, de taille inégale. Une fois chargés, certains QueryNodes se sont retrouvés avec plus de données que d'autres.

Cela a nui aux performances de trois manières :

  • Nœuds chauds : Les QueryNodes contenant des segments plus grands ou plus nombreux devaient effectuer plus de travail.

  • Effet du nœud le plus lent : la latence des requêtes distribuées dépend du nœud le plus lent.

  • Plus de surcharge de fusion : plus de segments signifiait également plus de travail lors de la fusion des résultats.

La correction

Nous avons supprimé --use_v2_restore et rétabli la logique par défaut :

./milvus-backup restore --config configs/restore.yaml -n backup_v2216

Nous avons d'abord nettoyé les mauvaises données du nouveau cluster, puis nous avons exécuté la restauration par défaut. La distribution des segments s'est rééquilibrée, la latence de recherche est revenue à la normale et le problème a disparu.

Ce que nous ferions différemment la prochaine fois

Dans ce cas, il nous a fallu trop de temps pour trouver le véritable problème : une répartition inégale des segments. Voici ce qui aurait permis d'accélérer les choses.

Améliorer la surveillance des segments

Milvus n'expose pas le nombre de segments, la distribution des lignes ou la distribution de la taille par collection dans les tableaux de bord Grafana standard. Nous avons dû fouiller manuellement dans Attu et etcd, ce qui était lent.

Il serait utile d'ajouter :

  • un tableau de bord de distribution des segments dans Grafana, montrant combien de segments chaque QueryNode a chargé, ainsi que leur nombre de lignes et leur taille.

  • une alerte de déséquilibre, déclenchée lorsque le nombre de lignes de segments sur les nœuds dépasse un certain seuil

  • une vue de comparaison de la migration, afin que les utilisateurs puissent comparer la distribution des segments entre l'ancien et le nouveau cluster après une mise à niveau.

Utiliser une liste de contrôle standard pour la migration

Nous avons vérifié le nombre de lignes et l'avons jugé correct. Ce n'était pas suffisant. Une validation post-migration complète doit également porter sur les points suivants

  • La cohérence du schéma. Les définitions des champs et les dimensions des vecteurs correspondent-elles ?

  • Le nombre de segments. Le nombre de segments a-t-il changé radicalement ?

  • Équilibre des segments. Le nombre de lignes dans les segments est-il raisonnablement homogène ?

  • Statut de l'index. Tous les index sont-ils finished?

  • Benchmark de latence. Les temps de latence des requêtes P50, P95 et P99 sont-ils similaires à ceux de l'ancien cluster ?

  • Équilibre de la charge. L'utilisation du CPU de QueryNode est-elle uniformément répartie entre les pods ?

Ajouter des contrôles automatisés

Vous pouvez scripter cette validation avec PyMilvus pour détecter les déséquilibres avant qu'ils n'atteignent la production :

from pymilvus import connections, utility, Collection  
def check_segment_balance(collection_name: str):
    """Check Segment distribution balance"""
    collection = Collection(collection_name)
    segments = utility.get_query_segment_info(collection_name)
    # Group statistics by QueryNode
    node_stats = {}
    for seg in segments:
        node_id = seg.nodeID
        if node_id not in node_stats:
            node_stats[node_id] = {"count": 0, "rows": 0}
        node_stats[node_id]["count"] += 1
        node_stats[node_id]["rows"] += seg.num_rows
    # Calculate balance
    row_counts = [v["rows"] for v in node_stats.values()]
    avg_rows = sum(row_counts) / len(row_counts)
    max_deviation = max(abs(r - avg_rows) / avg_rows for r in row_counts)
    print(f"Number of nodes: {len(node_stats)}")
    print(f"Average row count: {avg_rows:.0f}")
    print(f"Maximum deviation: {max_deviation:.2%}")
    if max_deviation > 0.2:  # Raise a warning if deviation exceeds 20%
        print("⚠️ Warning: Segment distribution is unbalanced and may affect query performance!")
    for node_id, stats in sorted(node_stats.items()):
        print(f"  Node {node_id}: {stats['count']} segments, {stats['rows']} rows")

# Usage example connections.connect(host=“localhost”, port=“19530”) check_segment_balance(“your_collection_name”)

Mieux utiliser les outils existants

Quelques outils prennent déjà en charge les diagnostics au niveau des segments :

  • Birdwatcher : peut lire les métadonnées Etcd directement et montrer la disposition des segments et l'affectation des canaux.

  • Milvus Web UI (v2.5+) : vous permet d'inspecter visuellement les informations sur les segments.

  • Grafana + Prometheus : peut être utilisé pour créer des tableaux de bord personnalisés pour la surveillance en temps réel des clusters.

Suggestions pour la communauté Milvus

Quelques modifications apportées à Milvus faciliteraient ce type de dépannage :

  1. Expliquer plus clairement la compatibilité des paramètresLadocumentation de milvus-backup devrait expliquer clairement comment les options telles que --use_v2_restore se comportent lors des restaurations inter-version et les risques qu'elles peuvent introduire.

  2. Ajouter de meilleures vérifications après la restaurationAprès lafin de restore, il serait utile que l'outil imprime automatiquement un résumé de la distribution des segments.

  3. Exposer les métriques liées à l'équilibreLesmétriques dePrometheusdevraient inclure des informations sur l'équilibre des segments, afin que les utilisateurs puissent les surveiller directement.

  4. Prise en charge de l'analyse du plan de requêteSimilaire àMySQL EXPLAIN, Milvus bénéficierait d'un outil qui montre comment une requête est exécutée et aide à localiser les problèmes de performance.

Conclusion

En résumé :

ÉtapeOutil / MéthodePoint clé
Sauvegardemilvus-backup createLa sauvegarde à chaud est prise en charge, mais la sauvegarde doit être vérifiée avec soin.
Mise à niveauConstruire un nouveau cluster avec HelmDésactiver Mmap pour réduire la gigue d'E/S et conserver les mêmes paramètres de ressources que l'ancien cluster.
Migrationmilvus-backup restoreSoyez prudent avec --use_v2_restore. Lors d'une restauration inter-version, n'utilisez pas de logique autre que celle par défaut, à moins que vous ne la compreniez clairement.
Déploiement grisDéplacement progressif du traficDéplacez le trafic par étapes : 5 % → 25 % → 50 % → 100 %, et gardez l'ancien cluster prêt pour le retour en arrière.
Résolution des problèmesGrafana + analyse des segmentsNe vous contentez pas de regarder le processeur et la mémoire. Vérifiez également l'équilibre des segments et la distribution des données
CorrectionSupprimer les mauvaises données et les restaurer à nouveauSupprimez le mauvais drapeau, restaurez avec la logique par défaut et les performances reviennent à la normale.

Lors de la migration des données, il est important de ne pas se contenter de vérifier si les données sont présentes et exactes. Vous devez également prêter attention à la manière dont les données sont distribuées.

Le nombre et la taille des segments déterminent la manière dont Milvus répartit le travail de requête entre les nœuds. Lorsque les segments sont déséquilibrés, quelques nœuds finissent par effectuer la majeure partie du travail, et chaque recherche en fait les frais. Les mises à niveau entre versions comportent un risque supplémentaire, car le processus de restauration peut reconstruire les segments différemment du cluster d'origine. Des drapeaux tels que --use_v2_restore peuvent fragmenter vos données d'une manière que le nombre de lignes ne suffit pas à révéler.

Par conséquent, l'approche la plus sûre lors d'une migration entre versions est de s'en tenir aux paramètres de restauration par défaut, sauf si vous avez une raison spécifique de faire autrement. En outre, la surveillance doit aller au-delà de l'unité centrale et de la mémoire ; vous devez avoir un aperçu de la disposition sous-jacente des données, en particulier de la distribution et de l'équilibre des segments, afin de détecter les problèmes plus tôt.

Note de l'équipe Milvus

Nous tenons à remercier l'équipe d'ingénieurs de WPS d'avoir partagé cette expérience avec la communauté Milvus. Les comptes rendus de ce type sont précieux car ils permettent de tirer des leçons de la production réelle et de les rendre utiles à d'autres personnes confrontées à des problèmes similaires.

Si votre équipe a une leçon technique, une histoire de dépannage ou une expérience pratique qui mérite d'être partagée, nous serions ravis de l'entendre. Rejoignez notre canal Slack et contactez-nous.

Et si vous êtes confronté à vos propres défis, ces mêmes canaux communautaires sont un bon moyen d'entrer en contact avec les ingénieurs Milvus et d'autres utilisateurs. Vous pouvez également réserver une session individuelle via les Heures de bureau Milvus pour obtenir de l'aide sur la sauvegarde et la restauration, les mises à niveau inter-version et les performances des requêtes.

    Try Managed Milvus for Free

    Zilliz Cloud is hassle-free, powered by Milvus and 10x faster.

    Get Started

    Like the article? Spread the word

    Continuer à Lire