milvus-logo
LFAI
Home
  • Guide d'administration

Tableau de bord des mesures de Milvus

Milvus produit une liste de métriques détaillées de séries temporelles pendant l'exécution. Vous pouvez utiliser Prometheus et Grafana pour visualiser les métriques. Cette rubrique présente les métriques de surveillance affichées dans le tableau de bord Grafana Milvus.

L'unité de temps utilisée dans cette rubrique est la milliseconde. Et "99ème percentile" dans cette rubrique fait référence au fait que 99 pour cent des statistiques de temps sont contrôlées dans une certaine valeur.

Nous vous recommandons de lire l'aperçu du cadre de surveillance Milvus pour comprendre d'abord les métriques Prometheus.

Proxy

PanelDescription du panneauPromQL (langage de requête Prometheus)Les métriques Milvus utiliséesDescription des métriques Milvus
Taux de comptage des vecteurs de rechercheNombre moyen de vecteurs interrogés par seconde par chaque proxy au cours des deux dernières minutes.sum(increase(milvus_proxy_search_vectors_count{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])/120) by (pod, node_id)milvus_proxy_search_vectors_countNombre cumulé de vecteurs interrogés.
Taux de comptage des vecteurs d'insertionNombre moyen de vecteurs insérés par seconde par chaque proxy au cours des deux dernières minutes.sum(increase(milvus_proxy_insert_vectors_count{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])/120) by (pod, node_id)milvus_proxy_insert_vectors_countNombre cumulé de vecteurs insérés.
Temps de latence de la rechercheTemps de latence moyen et 99e percentile du temps de latence pour la réception des demandes de recherche et d'interrogation par chaque mandataire au cours des deux dernières minutes.p99 :
histogram_quantile(0.99, sum by (le, query_type, pod, node_id) (rate(milvus_proxy_sq_latency_bucket{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])))
avg :
sum(increase(milvus_proxy_sq_latency_sum{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])) by (pod, node_id, query_type) / sum(increase(milvus_proxy_sq_latency_count{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])) by (pod, node_id, query_type)
milvus_proxy_sq_latencyTemps de latence des demandes de recherche et d'interrogation.
Temps de latence de la recherche dans la collectionTemps de latence moyen et 99e percentile de la latence de réception des demandes de recherche et d'interrogation d'une collection spécifique par chaque proxy au cours des deux dernières minutes.p99 :
histogram_quantile(0.99, sum by (le, query_type, pod, node_id) (rate(milvus_proxy_collection_sq_latency_bucket{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace", collection_name=~"$collection"}[2m])))
avg :
sum(increase(milvus_proxy_collection_sq_latency_sum{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace", collection_name=~"$collection"}[2m])) by (pod, node_id, query_type) / sum(increase(milvus_proxy_collection_sq_latency_count{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace", collection_name=~"$collection"}[2m])) by (pod, node_id, query_type)
milvus_proxy_collection_sq_latency_sumTemps de latence des demandes de recherche et d'interrogation d'une collection spécifique
Latence de mutationTemps de latence moyen et 99e percentile du temps de latence pour la réception de demandes de mutation par chaque proxy au cours des deux dernières minutes.p99 :
histogram_quantile(0.99, sum by (le, msg_type, pod, node_id) (rate(milvus_proxy_mutation_latency_bucket{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])))
avg :
sum(increase(milvus_proxy_mutation_latency_sum{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])) by (pod, node_id, msg_type) / sum(increase(milvus_proxy_mutation_latency_count{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])) by (pod, node_id, msg_type)
milvus_proxy_mutation_latency_sumTemps de latence des demandes de mutation.
Temps de latence de la mutation de la collectionTemps de latence moyen et 99e percentile de la latence de réception des demandes de mutation vers une collection spécifique par chaque proxy au cours des deux dernières minutes.p99 :
histogram_quantile(0.99, sum by (le, query_type, pod, node_id) (rate(milvus_proxy_collection_sq_latency_bucket{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace", collection_name=~"$collection"}[2m])))
avg :
sum(increase(milvus_proxy_collection_sq_latency_sum{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace", collection_name=~"$collection"}[2m])) by (pod, node_id, query_type) / sum(increase(milvus_proxy_collection_sq_latency_count{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace", collection_name=~"$collection"}[2m])) by (pod, node_id, query_type)
milvus_proxy_collection_sq_latency_sumTemps de latence des demandes de mutation vers une collection spécifique
Temps d'attente des résultats de rechercheTemps de latence moyen et 99e centile du temps de latence entre l'envoi de demandes de recherche et de requête et la réception des résultats par proxy au cours des deux dernières minutes.p99 :
histogram_quantile(0.99, sum by (le, query_type, pod, node_id) (rate(milvus_proxy_sq_wait_result_latency_bucket{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])))
avg :
sum(increase(milvus_proxy_sq_wait_result_latency_sum{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])) by (pod, node_id, query_type) / sum(increase(milvus_proxy_sq_wait_result_latency_count{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])) by (pod, node_id, query_type)
milvus_proxy_sq_wait_result_latencyTemps de latence entre l'envoi de demandes de recherche et de requête et la réception des résultats.
Réduire la latence des résultats de rechercheTemps de latence moyen et 99e percentile du temps de latence pour l'agrégation des résultats de recherche et de requête par proxy au cours des deux dernières minutes.p99 :
histogram_quantile(0.99, sum by (le, query_type, pod, node_id) (rate(milvus_proxy_sq_reduce_result_latency_bucket{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])))
avg :
sum(increase(milvus_proxy_sq_reduce_result_latency_sum{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])) by (pod, node_id, query_type) / sum(increase(milvus_proxy_sq_reduce_result_latency_count{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])) by (pod, node_id, query_type)
milvus_proxy_sq_reduce_result_latencyTemps de latence de l'agrégation des résultats de recherche et d'interrogation renvoyés par chaque nœud d'interrogation.
Temps de latence du décodage des résultats de rechercheTemps de latence moyen et 99e centile du temps de latence du décodage des résultats de recherche et d'interrogation par proxy au cours des deux dernières minutes.p99 :
histogram_quantile(0.99, sum by (le, query_type, pod, node_id) (rate(milvus_proxy_sq_decode_result_latency_bucket{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])))
avg :
sum(increase(milvus_proxy_sq_decode_result_latency_sum{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])) by (pod, node_id, query_type) / sum(increase(milvus_proxy_sq_decode_resultlatency_count{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])) by (pod, node_id, query_type)
milvus_proxy_sq_decode_result_latencyTemps de latence du décodage de chaque résultat de recherche et de requête.
Msg Stream Object NumNombre moyen, maximum et minimum d'objets msgstream créés par chaque proxy sur le sujet physique correspondant au cours des deux dernières minutes.avg(milvus_proxy_msgstream_obj_num{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}) by (pod, node_id) max(milvus_proxy_msgstream_obj_num{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}) by (pod, node_id) min(milvus_proxy_msgstream_obj_num{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}) by (pod, node_id)milvus_proxy_msgstream_obj_numLe nombre d'objets msgstream créés sur chaque sujet physique.
Latence d'envoi des mutationsTemps de latence moyen et 99e centile du temps de latence de l'envoi de demandes d'insertion ou de suppression par chaque proxy au cours des deux dernières minutes.p99 :
histogram_quantile(0.99, sum by (le, msg_type, pod, node_id) (rate(milvus_proxy_mutation_send_latency_bucket{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])))
avg :
sum(increase(milvus_proxy_mutation_send_latency_sum{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])) by (pod, node_id, msg_type) / sum(increase(milvus_proxy_mutation_send_latency_count{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])) by (pod, node_id, msg_type)
milvus_proxy_mutation_send_latencyTemps de latence pour l'envoi de demandes d'insertion ou de suppression.
Taux de réussite du cacheLe taux moyen de réussite des opérations dans le cache, y compris GeCollectionID, GetCollectionInfo, et GetCollectionSchema par seconde au cours des deux dernières minutes.sum(increase(milvus_proxy_cache_hit_count{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace", cache_state="hit"}[2m])/120) by(cache_name, pod, node_id) / sum(increase(milvus_proxy_cache_hit_count{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])/120) by(cache_name, pod, node_id)milvus_proxy_cache_hit_countStatistiques des taux de réussite et d'échec de chaque opération de lecture du cache.
Latence de mise à jour de la mémoire cacheLa latence moyenne et le 99e percentile de la latence de mise à jour du cache par proxy au cours des deux dernières minutes.p99 :
histogram_quantile(0.99, sum by (le, pod, node_id) (rate(milvus_proxy_cache_update_latency_bucket{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])))
avg :
sum(increase(milvus_proxy_cache_update_latency_sum{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])) by (pod, node_id) / sum(increase(milvus_proxy_cache_update_latency_count{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])) by (pod, node_id)
milvus_proxy_cache_update_latencyTemps de latence de la mise à jour du cache à chaque fois.
Temps de synchronisationLe nombre moyen, maximum et minimum d'heures d'horloge synchronisées par chaque proxy dans le canal physique correspondant.avg(milvus_proxy_sync_epoch_time{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}) by (pod, node_id) max(milvus_proxy_sync_epoch_time{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}) by (pod, node_id) min(milvus_proxy_sync_epoch_time{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}) by (pod, node_id)milvus_proxy_sync_epoch_timeL'heure d'origine de chaque canal physique (heure Unix, millisecondes écoulées depuis le 1er janvier 1970).
Il y a un ChannelName par défaut en dehors des canaux physiques.
Appliquer la latence PKLa latence moyenne et le 99ème percentile de la latence de l'application de la clé primaire par chaque proxy au cours des deux dernières minutes.p99 :
histogram_quantile(0.99, sum by (le, pod, node_id) (rate(milvus_proxy_apply_pk_latency_bucket{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])))
avg :
sum(increase(milvus_proxy_apply_pk_latency_sum{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])) by (pod, node_id) / sum(increase(milvus_proxy_apply_pk_latency_count{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])) by (pod, node_id)
milvus_proxy_apply_pk_latencyLe temps de latence de l'application de la clé primaire.
Temps de latence de l'horodatage de l'applicationLe temps de latence moyen et le 99ème percentile du temps de latence de l'application de l'horodatage par chaque proxy au cours des deux dernières minutes.p99 :
histogram_quantile(0.99, sum by (le, pod, node_id) (rate(milvus_proxy_apply_timestamp_latency_bucket{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])))
avg :
sum(increase(milvus_proxy_apply_timestamp_latency_sum{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])) by (pod, node_id) / sum(increase(milvus_proxy_apply_timestamp_latency_count{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])) by (pod, node_id)
milvus_proxy_apply_timestamp_latencyLe temps de latence de l'application de l'horodatage.
Taux de réussite des demandesLe nombre de requêtes réussies reçues par seconde par chaque proxy, avec une ventilation détaillée de chaque type de requête. Les types de demandes possibles sont DescribeCollection, DescribeIndex, GetCollectionStatistics, HasCollection, Search, Query, ShowPartitions, Insert, etc.
sum(increase(milvus_proxy_req_count{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace", status="success"}[2m])/120) by(function_name, pod, node_id)milvus_proxy_req_countNombre de tous les types de demandes reçues
Taux d'échec des demandesLe nombre de demandes échouées reçues par seconde par chaque proxy, avec une ventilation détaillée de chaque type de demande. Les types de demandes possibles sont DescribeCollection, DescribeIndex, GetCollectionStatistics, HasCollection, Search, Query, ShowPartitions, Insert, etc.
sum(increase(milvus_proxy_req_count{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace", status="fail"}[2m])/120) by(function_name, pod, node_id)milvus_proxy_req_countNombre de tous les types de demandes reçues
Temps de latence des requêtesLa latence moyenne et le 99e percentile de la latence de tous les types de requêtes reçues par chaque proxy.p99 :
histogram_quantile(0.99, sum by (le, pod, node_id, function_name) (rate(milvus_proxy_req_latency_bucket{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])))
avg :
sum(increase(milvus_proxy_req_latency_sum{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])) by (pod, node_id, function_name) / sum(increase(milvus_proxy_req_latency_count{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])) by (pod, node_id, function_name)
milvus_proxy_req_latencyLe temps de latence de tous les types de demandes de réception
Taux d'octets des demandes d'insertion/suppressionNombre d'octets de demandes d'insertion et de suppression reçus par seconde par le proxy au cours des deux dernières minutes.sum(increase(milvus_proxy_receive_bytes_count{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])/120) by(pod, node_id)milvus_proxy_receive_bytes_countLe nombre de demandes d'insertion et de suppression.
Taux d'envoi d'octetsNombre d'octets par seconde renvoyés au client pendant que chaque proxy répond aux demandes de recherche et de requête au cours des deux dernières minutes.sum(increase(milvus_proxy_send_bytes_count{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])/120) by(pod, node_id)milvus_proxy_send_bytes_countNombre d'octets renvoyés au client pendant que chaque proxy répond aux demandes de recherche et d'interrogation.

Coordinateur racine

PanneauDescription du panelPromQL (langage de requête Prometheus)Les métriques Milvus utiliséesDescription des métriques Milvus
Proxy Node NumNombre de proxies créés.sum(milvus_rootcoord_proxy_num{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}) by (app_kubernetes_io_instance)milvus_rootcoord_proxy_numLe nombre de proxies.
Sync TimeLe nombre moyen, maximum et minimum de temps d'époque synchronisés par chaque coordonnée racine dans chaque canal physique (PChannel).avg(milvus_rootcoord_sync_epoch_time{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}) by (app_kubernetes_io_instance) max(milvus_rootcoord_sync_epoch_time{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}) by (app_kubernetes_io_instance) min(milvus_rootcoord_sync_epoch_time{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}) by (app_kubernetes_io_instance)milvus_rootcoord_sync_epoch_timeL'heure de référence de chaque canal physique (heure Unix, millisecondes écoulées depuis le 1er janvier 1970).
Taux de requêtes DDLL'état et le nombre de requêtes DDL par seconde au cours des deux dernières minutes.sum(increase(milvus_rootcoord_ddl_req_count{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])/120) by (status, function_name)milvus_rootcoord_ddl_req_countLe nombre total de requêtes DDL, y compris CreateCollection, DescribeCollection, DescribeSegments, HasCollection, ShowCollections, ShowPartitions, et ShowSegments.
Temps de latence des requêtes DDLLa latence moyenne et le 99e percentile de la latence des requêtes DDL au cours des deux dernières minutes.p99 :
histogram_quantile(0.99, sum by (le, function_name) (rate(milvus_rootcoord_ddl_req_latency_bucket{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])))
avg :
sum(increase(milvus_rootcoord_ddl_req_latency_sum{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])) by (function_name) / sum(increase(milvus_rootcoord_ddl_req_latency_count{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])) by (function_name)
milvus_rootcoord_ddl_req_latencyLe temps de latence de tous les types de requêtes DDL.
Sync Timetick Latency (Temps de latence de la synchronisation)La latence moyenne et le 99ème percentile du temps utilisé par root coord pour synchroniser tous les horodatages avec PChannel au cours des deux dernières minutes.p99 :
histogram_quantile(0.99, sum by (le) (rate(milvus_rootcoord_sync_timetick_latency_bucket{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])))
avg :
sum(increase(milvus_rootcoord_sync_timetick_latency_sum{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])) / sum(increase(milvus_rootcoord_sync_timetick_latency_count{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m]))
milvus_rootcoord_sync_timetick_latencyle temps utilisé par le coordonnateur principal pour synchroniser tous les horodatages avec le canal PC.
ID Alloc RateLe nombre d'identifiants attribués par le coordinateur racine par seconde au cours des deux dernières minutes.sum(increase(milvus_rootcoord_id_alloc_count{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])/120)milvus_rootcoord_id_alloc_countLe nombre cumulé d'identifiants attribués par le coordinateur racine.
HorodatageL'horodatage le plus récent du coordonnateur racine.milvus_rootcoord_timestamp{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}milvus_rootcoord_timestampDernier horodatage de la coordonnée racine.
Horodatage sauvegardéLes horodatages pré-assignés que la racine de la coordination enregistre dans le méta stockage.milvus_rootcoord_timestamp_saved{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}milvus_rootcoord_timestamp_savedLes horodatages pré-assignés que le coordonnateur racine enregistre dans le méta-mémoire.
Les horodatages sont attribués 3 secondes plus tôt. L'horodatage est mis à jour et enregistré dans le méta-magasin toutes les 50 millisecondes.
Collection NumLe nombre total de collections.sum(milvus_rootcoord_collection_num{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}) by (app_kubernetes_io_instance)milvus_rootcoord_collection_numLe nombre total de collections existant actuellement dans Milvus.
Partition NumLe nombre total de partitions.sum(milvus_rootcoord_partition_num{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}) by (app_kubernetes_io_instance)milvus_rootcoord_partition_numLe nombre total de partitions existant actuellement dans Milvus.
Canal DML NumLe nombre total de canaux DML.sum(milvus_rootcoord_dml_channel_num{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}) by (app_kubernetes_io_instance)milvus_rootcoord_dml_channel_numLe nombre total de canaux DML existant actuellement dans Milvus.
Msgstream NumNombre total de flux de messages.sum(milvus_rootcoord_msgstream_obj_num{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}) by (app_kubernetes_io_instance)milvus_rootcoord_msgstream_obj_numLe nombre total de flux de messages dans Milvus actuellement.
Credential NumNombre total d'informations d'identification.sum(milvus_rootcoord_credential_num{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}) by (app_kubernetes_io_instance)milvus_rootcoord_credential_numLe nombre total d'informations d'identification dans Milvus actuellement.
Time Tick DelaySomme des délais maximums des graphiques de flux sur tous les DataNodes et QueryNodes.sum(milvus_rootcoord_time_tick_delay{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}) by (app_kubernetes_io_instance)milvus_rootcoord_time_tick_delayLe délai maximum des graphiques de flux sur chaque DataNode et QueryNode.

Coordinateur de requête

PanneauDescription du panneauPromQL (langage de requête Prometheus)Les métriques Milvus utiliséesDescription des métriques Milvus
Collection Loaded NumNombre de collections actuellement chargées en mémoire.sum(milvus_querycoord_collection_num{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}) by (app_kubernetes_io_instance)milvus_querycoord_collection_numNombre de collections actuellement chargées par Milvus.
Entité chargée NumNombre d'entités actuellement chargées en mémoire.sum(milvus_querycoord_entity_num{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}) by (app_kubernetes_io_instance)milvus_querycoord_entitiy_numNombre d'entités actuellement chargées par Milvus.
Taux de demande de chargementNombre de demandes de chargement par seconde au cours des deux dernières minutes.sum(increase(milvus_querycoord_load_req_count{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])120) by (status)milvus_querycoord_load_req_countNombre cumulé de demandes de chargement.
Taux de demande de libérationNombre de demandes de libération par seconde au cours des deux dernières minutes.sum(increase(milvus_querycoord_release_req_count{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])/120) by (status)milvus_querycoord_release_req_countNombre cumulé de demandes de libération.
Temps de latence des demandes de chargementLa latence moyenne et le 99e percentile de la latence des demandes de chargement au cours des deux dernières minutes.p99 :
histogram_quantile(0.99, sum by (le) (rate(milvus_querycoord_load_latency_bucket{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])))
avg :
sum(increase(milvus_querycoord_load_latency_sum{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])) / sum(increase(milvus_querycoord_load_latency_count{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m]))
milvus_querycoord_load_latencyTemps nécessaire à l'exécution d'une demande de chargement.
Latence de la demande de libérationLe temps de latence moyen et le 99ème percentile du temps de latence des demandes de libération au cours des deux dernières minutes.p99 :
histogram_quantile(0.99, sum by (le) (rate(milvus_querycoord_release_latency_bucket{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])))
moyenne :
sum(increase(milvus_querycoord_release_latency_sum{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])) / sum(increase(milvus_querycoord_release_latency_count{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m]))
milvus_querycoord_release_latencyLe temps nécessaire à l'exécution d'une demande de libération.
Sub-Load TaskNombre de tâches de sous-charge.sum(milvus_querycoord_child_task_num{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}) by (app_kubernetes_io_instance)milvus_querycoord_child_task_numNombre de tâches de sous-charge.
Une coordonnée de requête divise une demande de charge en plusieurs tâches de charge secondaires.
Tâche de charge principaleNombre de tâches de chargement parent.sum(milvus_querycoord_parent_task_num{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}) by (app_kubernetes_io_instance)milvus_querycoord_parent_task_numNombre de sous-tâches de charge.
Chaque demande de charge correspond à une tâche parent dans la file d'attente des tâches.
Latence de la tâche de sous-chargeLa latence moyenne et le 99e percentile de la latence d'une tâche de sous-charge au cours des deux dernières minutes.p99 :
histogram_quantile(0.99, sum by (le) (rate(milvus_querycoord_child_task_latency_bucket{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])))
avg :
sum(increase(milvus_querycoord_child_task_latency_sum{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])) / sum(increase(milvus_querycoord_child_task_latency_count{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])) namespace"}[2m])))
milvus_querycoord_child_task_latencyTemps d'attente pour terminer une tâche de sous-charge.
Query Node NumNombre de nœuds de requête gérés par query coord.sum(milvus_querycoord_querynode_num{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}) by (app_kubernetes_io_instance)milvus_querycoord_querynode_numNombre de nœuds de requête gérés par la coordination des requêtes.

Nœud de requête

PanneauDescription du panneauPromQL (langage de requête Prometheus)Les métriques Milvus utiliséesDescription des métriques Milvus
Collection Loaded NumNombre de collections chargées en mémoire par chaque nœud de requête.sum(milvus_querynode_collection_num{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}) by (pod, node_id)milvus_querynode_collection_numNombre de collections chargées par chaque nœud de requête.
Partition chargée NumNombre de partitions chargées en mémoire par chaque nœud d'interrogation.sum(milvus_querynode_partition_num{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}) by (pod, node_id)milvus_querynode_partition_numNombre de partitions chargées par chaque nœud d'interrogation.
Segment chargé NumNombre de segments chargés en mémoire par chaque nœud d'interrogation.sum(milvus_querynode_segment_num{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}) by (pod, node_id)milvus_querynode_segment_numNombre de segments chargés par chaque nœud d'interrogation.
Entité interrogeable NumNombre d'entités interrogeables et consultables sur chaque nœud d'interrogation.sum(milvus_querynode_entity_num{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}) by (pod, node_id)milvus_querynode_entity_numNombre d'entités interrogeables et consultables sur chaque nœud d'interrogation.
Canal virtuel DMLNombre de canaux virtuels DML surveillés par chaque nœud d'interrogation.sum(milvus_querynode_dml_vchannel_num{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}) by (pod, node_id)milvus_querynode_dml_vchannel_numNombre de canaux virtuels DML surveillés par chaque nœud d'interrogation.
Canal virtuel DeltaNombre de canaux delta surveillés par chaque nœud d'interrogation.sum(milvus_querynode_delta_vchannel_num{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}) by (pod, node_id)milvus_querynode_delta_vchannel_numNombre de canaux delta surveillés par chaque nœud de requête.
Consumer NumNombre de consommateurs dans chaque noeud de requête.sum(milvus_querynode_consumer_num{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}) by (pod, node_id)milvus_querynode_consumer_numNombre de consommateurs dans chaque nœud de requête.
Taux de requêtes de rechercheNombre total de demandes de recherche et d'interrogation reçues par seconde par chaque nœud d'interrogation et nombre de demandes de recherche et d'interrogation réussies au cours des deux dernières minutes.sum(increase(milvus_querynode_sq_req_count{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])/120) by (query_type, status, pod, node_id)milvus_querynode_sq_req_countNombre cumulé de demandes de recherche et d'interrogation.
Temps de latence des requêtes de rechercheLa latence moyenne et le 99e percentile du temps utilisé pour les requêtes de recherche et d'interrogation par chaque nœud d'interrogation au cours des deux dernières minutes.
Ce panneau affiche la latence des requêtes de recherche et d'interrogation dont l'état est "succès" ou "total".
p99 :
histogram_quantile(0.99, sum by (le, pod, node_id) (rate(milvus_querynode_sq_req_latency_bucket{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])))
avg :
sum(increase(milvus_querynode_sq_req_latency_sum{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])) by(pod, node_id, query_type) / sum(increase(milvus_querynode_sq_req_latency_count{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])) by(pod, node_id, query_type)
milvus_querynode_sq_req_latencyTemps de latence de la demande de recherche du nœud d'interrogation.
Temps de latence de la recherche dans la file d'attenteTemps de latence moyen et 99e centile du temps de latence des requêtes de recherche et d'interrogation en file d'attente au cours des deux dernières minutes.p99 :
histogram_quantile(0.99, sum by (le, pod, node_id, query_type) (rate(milvus_querynode_sq_queue_latency_bucket{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])))
avg :
sum(increase(milvus_querynode_sq_queue_latency_sum{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])) by(pod, node_id, query_type) / sum(increase(milvus_querynode_sq_queue_latency_count{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])) by(pod, node_id, query_type)
milvus_querynode_sq_queue_latencyTemps de latence des requêtes de recherche et d'interrogation reçues par le nœud d'interrogation.
Temps de latence du segment de rechercheLa latence moyenne et le 99e percentile du temps nécessaire à chaque nœud de requête pour rechercher et interroger un segment au cours des deux dernières minutes.
L'état d'un segment peut être scellé ou en croissance.
p99 :
histogram_quantile(0.99, sum by (le, query_type, segment_state, pod, node_id) (rate(milvus_querynode_sq_segment_latency_bucket{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])))
avg :
sum(increase(milvus_querynode_sq_segment_latency_sum{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])) by(pod, node_id, query_type, segment_state) / sum(increase(milvus_querynode_sq_segment_latency_count{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])) by(pod, node_id, query_type, segment_state)
milvus_querynode_sq_segment_latencyTemps nécessaire à chaque nœud de requête pour rechercher et interroger chaque segment.
Temps de latence des requêtes SegcoreTemps de latence moyen et 99e percentile du temps nécessaire à chaque nœud de requête pour effectuer une recherche et une requête dans le segcore au cours des deux dernières minutes.p99 :
histogram_quantile(0.99, sum by (le, query_type, pod, node_id) (rate(milvus_querynode_sq_core_latency_bucket{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])))
avg :
sum(increase(milvus_querynode_sq_core_latency_sum{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])) by(pod, node_id, query_type) / sum(increase(milvus_querynode_sq_core_latency_count{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])) by(pod, node_id, query_type)
milvus_querynode_sq_core_latencyTemps nécessaire à chaque nœud de requête pour effectuer une recherche et une requête dans segcore.
Temps de latence de la réduction de la rechercheTemps de latence moyen et 99e percentile du temps utilisé par chaque nœud de requête pendant l'étape de réduction d'une recherche ou d'une requête au cours des deux dernières minutes.p99 :
histogram_quantile(0.99, sum by (le, pod, node_id, query_type) (rate(milvus_querynode_sq_reduce_latency_bucket{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])))
avg :
sum(increase(milvus_querynode_sq_reduce_latency_sum{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])) by(pod, node_id, query_type) / sum(increase(milvus_querynode_sq_reduce_latency_count{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])) by(pod, node_id, query_type)
milvus_querynode_sq_reduce_latencyLe temps que chaque requête passe pendant l'étape de réduction.
Temps de latence du segment de chargeTemps de latence moyen et 99e percentile du temps nécessaire à chaque nœud de requête pour charger un segment au cours des deux dernières minutes.p99 :
histogram_quantile(0.99, sum by (le, pod, node_id) (rate(milvus_querynode_load_segment_latency_bucket{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])))
avg :
sum(increase(milvus_querynode_load_segment_latency_sum{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])) by(pod, node_id) / sum(increase(milvus_querynode_load_segment_latency_count{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])) by(pod, node_id)
milvus_querynode_load_segment_latency_bucketTemps nécessaire à chaque nœud de requête pour charger un segment.
Flowgraph NumNombre d'organigrammes dans chaque nœud de requête.sum(milvus_querynode_flowgraph_num{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}) by (pod, node_id)milvus_querynode_flowgraph_numLe nombre de diagrammes de flux dans chaque nœud d'interrogation.
Longueur des tâches de lecture non résoluesLongueur de la file d'attente des demandes de lecture non résolues dans chaque nœud d'interrogation.sum(milvus_querynode_read_task_unsolved_len{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}) by (pod, node_id)milvus_querynode_read_task_unsolved_lenLongueur de la file d'attente des demandes de lecture non résolues.
Longueur de la tâche de lecture prêteLongueur de la file d'attente des demandes de lecture à exécuter dans chaque nœud d'interrogation.sum(milvus_querynode_read_task_ready_len{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}) by (pod, node_id)milvus_querynode_read_task_ready_lenLongueur de la file d'attente des demandes de lecture à exécuter.
Tâche de lecture parallèle (Parallel Read Task Num)Nombre de requêtes de lecture simultanées actuellement exécutées dans chaque noeud de requête.sum(milvus_querynode_read_task_concurrency{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}) by (pod, node_id)milvus_querynode_read_task_concurrencyLe nombre de requêtes de lecture simultanées actuellement exécutées.
Estimate CPU UsageL'utilisation du CPU par chaque noeud de requête estimée par le planificateur.sum(milvus_querynode_estimate_cpu_usage{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}) by (pod, node_id)milvus_querynode_estimate_cpu_usageL'utilisation du CPU par chaque noeud de requête estimée par le planificateur.
Lorsque la valeur est de 100, cela signifie qu'un CPU virtuel (vCPU) entier est utilisé.
Taille du groupe de rechercheLe nombre moyen et le 99e centile de la taille du groupe de recherche (c'est-à-dire le nombre total de requêtes de recherche originales dans les requêtes de recherche combinées exécutées par chaque nœud de requête) au cours des deux dernières minutes.p99 :
histogram_quantile(0.99, sum by (le, pod, node_id) (rate(milvus_querynode_search_group_size_bucket{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])))
avg :
sum(increase(milvus_querynode_search_group_size_sum{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])) by(pod, node_id) / sum(increase(milvus_querynode_search_group_size_count{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])) by(pod, node_id)
milvus_querynode_load_segment_latency_bucketLe nombre de tâches de recherche originales parmi les tâches de recherche combinées de différents ensembles (c.-à-d. la taille du groupe de recherche).
Recherche NQLe nombre moyen et le 99e percentile du nombre de requêtes (NQ) effectuées lorsque chaque nœud de requête exécute des requêtes de recherche au cours des deux dernières minutes.p99 :
histogram_quantile(0.99, sum by (le, pod, node_id) (rate(milvus_querynode_search_group_size_bucket{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])))
avg :
sum(increase(milvus_querynode_search_group_size_sum{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])) by(pod, node_id) / sum(increase(milvus_querynode_search_group_size_count{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])) by(pod, node_id)
Milvus_querynode_load_segment_latency_bucketLe nombre de requêtes (NQ) des demandes de recherche.
Groupe de recherche NQLe nombre moyen et le 99e centile du NQ des requêtes de recherche combinées et exécutées par chaque nœud de requête au cours des deux dernières minutes.p99 :
histogram_quantile(0.99, sum by (le, pod, node_id) (rate(milvus_querynode_search_group_nq_bucket{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])))
avg :
sum(increase(milvus_querynode_search_group_nq_sum{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])) by(pod, node_id) / sum(increase(milvus_querynode_search_group_nq_count{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])) by(pod, node_id)
milvus_querynode_load_segment_latency_bucketLe NQ des requêtes de recherche combinées à partir de différentes catégories.
Recherche Top_KNombre moyen et 99e percentile de Top_K des demandes de recherche exécutées par chaque nœud d'interrogation au cours des deux dernières minutes.p99 :
histogram_quantile(0.99, sum by (le, pod, node_id) (rate(milvus_querynode_search_topk_bucket{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])))
avg :
sum(increase(milvus_querynode_search_topk_sum{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])) by(pod, node_id) / sum(increase(milvus_querynode_search_topk_count{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])) by(pod, node_id)
milvus_querynode_load_segment_latency_bucketLe Top_K des demandes de recherche.
Groupe de recherche Top_KNombre moyen et 99e centile des Top_K demandes de recherche combinées et exécutées par chaque nœud d'interrogation au cours des deux dernières minutes.p99 :
histogram_quantile(0.99, sum by (le, pod, node_id) (rate(milvus_querynode_search_group_topk_bucket{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])))
avg :
sum(increase(milvus_querynode_search_group_topk_sum{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])) by(pod, node_id) / sum(increase(milvus_querynode_search_group_topk_count{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])) by(pod, node_id)
milvus_querynode_load_segment_latency_bucketLe Top_K des requêtes de recherche combinées à partir de différents ensembles.
Taux de requêtes de lecture évincéesNombre de demandes de lecture expulsées par seconde par chaque nœud d'interrogation au cours des deux dernières minutes.sum(increase(milvus_querynode_read_evicted_count{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])/120) by (pod, node_id)milvus_querynode_sq_req_countLe nombre cumulé de requêtes de lecture évincées par le nœud d'interrogation en raison d'une restriction du trafic.

Coordinateur de données

PanneauDescription du panelPromQL (langage de requête Prometheus)Les métriques Milvus utiliséesDescription des métriques Milvus
Data Node NumNombre de nœuds de données gérés par le coordinateur des données.sum(milvus_datacoord_datanode_num{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}) by (app_kubernetes_io_instance)milvus_datacoord_datanode_numNombre de nœuds de données gérés par la coordinatrice des données.
Segment NumNombre de tous les types de segments enregistrés dans les métadonnées par la coordination des données.sum(milvus_datacoord_segment_num{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}) by (segment_state)milvus_datacoord_segment_numNombre de tous les types de segments enregistrés dans les métadonnées par la coordonnatrice des données.
Les types de segments sont les suivants : dropped, flushed, flushing, growing et sealed.
Collection NumNombre de collections enregistrées dans les métadonnées par la coordonnatrice des données.sum(milvus_datacoord_collection_num{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}) by (app_kubernetes_io_instance)milvus_datacoord_collection_numNombre de collections enregistrées dans les métadonnées par la coordonnatrice des données.
Lignes stockéesNombre cumulé de lignes de données valides et effacées dans la coordonnée des données.sum(milvus_datacoord_stored_rows_num{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}) by (app_kubernetes_io_instance)milvus_datacoord_stored_rows_numNombre cumulé de lignes de données valides et effacées dans la coordonnée des données.
Taux de lignes stockéesNombre moyen de lignes extraites par seconde au cours des deux dernières minutes.sum(increase(milvus_datacoord_stored_rows_count{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])/120) by (pod, node_id)milvus_datacoord_stored_rows_countLe nombre cumulé de lignes extraites par la coordonnée des données.
Temps de synchronisationLe nombre moyen, maximum et minimum de temps de synchronisation par coordonnée de données dans chaque canal physique.avg(milvus_datacoord_sync_epoch_time{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}) by (app_kubernetes_io_instance) max(milvus_datacoord_sync_epoch_time{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}) by (app_kubernetes_io_instance) min(milvus_datacoord_sync_epoch_time{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}) by (app_kubernetes_io_instance)milvus_datacoord_sync_epoch_timeL'heure de référence de chaque canal physique (heure Unix, millisecondes écoulées depuis le 1er janvier 1970).
Taille du journal stockéTaille totale du journal stocké.sum(milvus_datacoord_stored_binlog_size{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}) by (app_kubernetes_io_instance)milvus_datacoord_stored_binlog_sizeTaille totale du journal stocké dans Milvus.

Nœud de données

PanneauDescription du panneauPromQL (langage de requête Prometheus)Les métriques Milvus utiliséesDescription des métriques Milvus
Flowgraph NumNombre d'objets de l'organigramme correspondant à chaque nœud de données.sum(milvus_datanode_flowgraph_num{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}) by (pod, node_id)milvus_datanode_flowgraph_numNombre d'objets de graphe de flux.
Chaque tesson d'une collection correspond à un objet de graphe de flux.
Msg Rows Consume RateNombre de lignes de messages en continu consommées par seconde par chaque nœud de données au cours des deux dernières minutes.sum(increase(milvus_datanode_msg_rows_count{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])/120) by (msg_type, pod, node_id)milvus_datanode_msg_rows_countNombre de lignes de messages en continu consommées.
Actuellement, les messages en continu comptabilisés par nœud de données ne comprennent que les messages d'insertion et de suppression.
Taux de taille des données de vidangeLa taille de chaque message de vidange enregistrée par seconde par chaque nœud de données au cours des deux dernières minutes.sum(increase(milvus_datanode_flushed_data_size{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])/120) by (msg_type, pod, node_id)milvus_datanode_flushed_data_sizeLa taille de chaque message envoyé.
Actuellement, les messages en continu comptabilisés par nœud de données ne comprennent que les messages d'insertion et de suppression.
Consumer NumNombre de consommateurs créés sur chaque nœud de données.sum(milvus_datanode_consumer_num{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}) by (pod, node_id)milvus_datanode_consumer_numNombre de consommateurs créés sur chaque nœud de données.
Chaque organigramme correspond à un consommateur.
Producer NumNombre de producteurs créés sur chaque nœud de données.sum(milvus_datanode_producer_num{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}) by (pod, node_id)milvus_datanode_producer_numNombre de consommateurs créés sur chaque nœud de données.
Chaque tesson d'une collection correspond à un producteur de canal delta et à un producteur de canal timetick.
Sync TimeNombre moyen, maximum et minimum de temps d'époque synchronisés par chaque nœud de données dans tous les thèmes physiques.avg(milvus_datanode_sync_epoch_time{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}) by (pod, node_id) max(milvus_datanode_sync_epoch_time{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}) by (pod, node_id) min(milvus_datanode_sync_epoch_time{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}) by (pod, node_id)milvus_datanode_sync_epoch_timeL'heure d'origine (heure Unix, millisecondes écoulées depuis le 1er janvier 1970) de chaque sujet physique sur un noeud de données.
Unflushed Segment NumNombre de segments non vidés créés sur chaque noeud de données.sum(milvus_datanode_unflushed_segment_num{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}) by (pod, node_id)milvus_datanode_unflushed_segment_numNombre de segments non vidés créés sur chaque nœud de données.
Encode Buffer LatencyLa latence moyenne et le 99e percentile du temps utilisé pour encoder un tampon par chaque nœud de données au cours des deux dernières minutes.p99 :
histogram_quantile(0.99, sum by (le, pod, node_id) (rate(milvus_datanode_encode_buffer_latency_bucket{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])))
avg :
sum(increase(milvus_datanode_encode_buffer_latency_sum{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])) by(pod, node_id) / sum(increase(milvus_datanode_encode_buffer_latency_count{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])) by(pod, node_id)
milvus_datanode_encode_buffer_latencyTemps nécessaire à chaque nœud de données pour encoder une mémoire tampon.
Sauvegarde de la latence des donnéesTemps de latence moyen et 99e percentile du temps utilisé pour écrire un tampon dans la couche de stockage par chaque nœud de données au cours des deux dernières minutes.p99 :
histogram_quantile(0.99, sum by (le, pod, node_id) (rate(milvus_datanode_save_latency_bucket{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])))
avg :
sum(increase(milvus_datanode_save_latency_sum{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])) by(pod, node_id) / sum(increase(milvus_datanode_save_latency_count{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])) by(pod, node_id)
milvus_datanode_save_latencyTemps nécessaire à chaque nœud de données pour écrire un tampon dans la couche de stockage.
Taux d'opération de rinçageNombre de fois où chaque nœud de données vide une mémoire tampon par seconde au cours des deux dernières minutes.sum(increase(milvus_datanode_flush_buffer_op_count{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])/120) by (status, pod, node_id)milvus_datanode_flush_buffer_op_countNombre cumulé de fois qu'un nœud de données vide une mémoire tampon.
Taux d'opération de vidange automatiqueNombre de fois où chaque nœud de données a procédé à une vidange automatique de la mémoire tampon par seconde au cours des deux dernières minutes.sum(increase(milvus_datanode_autoflush_buffer_op_count{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])/120) by (status, pod, node_id)milvus_datanode_autoflush_buffer_op_countNombre cumulé de fois qu'un nœud de données vide automatiquement une mémoire tampon.
Taux de demande de vidangeNombre de fois où chaque nœud de données reçoit une demande de vidange de la mémoire tampon par seconde au cours des deux dernières minutes.sum(increase(milvus_datanode_flush_req_count{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])/120) by (status, pod, node_id)milvus_datanode_flush_req_countNombre cumulé de fois où un noeud de données reçoit une demande de vidange de la part d'une coordonnée.
Latence de compactageLa latence moyenne et le percentile 99 du temps nécessaire à chaque nœud de données pour exécuter une tâche de compactage au cours des deux dernières minutes.p99 :
histogram_quantile(0.99, sum by (le, pod, node_id) (rate(milvus_datanode_compaction_latency_bucket{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])))
avg :
sum(increase(milvus_datanode_compaction_latency_sum{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])) by(pod, node_id) / sum(increase(milvus_datanode_compaction_latency_count{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])) by(pod, node_id)
milvus_datanode_compaction_latencyLe temps nécessaire à chaque nœud de données pour exécuter une tâche de compactage.

Coordinateur de l'index

PanneauDescription du panelPromQL (langage de requête Prometheus)Les métriques Milvus utiliséesDescription des métriques Milvus
Taux de demande d'indexNombre moyen de demandes de construction d'index reçues par seconde au cours des deux dernières minutes.sum(increase(milvus_indexcoord_indexreq_count{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])/120) by (status)milvus_indexcoord_indexreq_countNombre de demandes de construction d'index reçues.
Nombre de tâches d'indexationNombre de tâches d'indexation enregistrées dans les métadonnées d'index.sum(milvus_indexcoord_indextask_count{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}) by (index_task_status)milvus_indexcoord_indextask_countNombre de tâches d'indexation enregistrées dans les métadonnées d'index.
Index Node NumNombre de nœuds d'index gérés.sum(milvus_indexcoord_indexnode_num{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}) by (app_kubernetes_io_instance)milvus_indexcoord_indexnode_numNombre de nœuds d'index gérés.

Nœud d'index

PanneauDescription du panneauPromQL (langage de requête Prometheus)Les métriques Milvus utiliséesDescription des métriques Milvus
Taux de tâches d'indexationNombre moyen de tâches de construction d'index reçues par chaque nœud d'index par seconde au cours des deux dernières minutes.sum(increase(milvus_indexnode_index_task_count{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])/120) by (status, pod, node_id)milvus_indexnode_index_task_countNombre de tâches de construction d'index reçues.
Latence du champ de chargeLa latence moyenne et le 99e percentile du temps utilisé par chaque nœud d'index pour charger les données de champ de segment à chaque fois au cours des deux dernières minutes.p99 :
histogram_quantile(0.99, sum by (le, pod, node_id) (rate(milvus_indexnode_load_field_latency_bucket{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])))
avg :
sum(increase(milvus_indexnode_load_field_latency_sum{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])) by(pod, node_id) / sum(increase(milvus_indexnode_load_field_latency_count{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])) by(pod, node_id)
milvus_indexnode_load_field_latencyTemps utilisé par le nœud d'index pour charger les données du champ de segment.
Temps de latence du champ de décodageTemps de latence moyen et 99e percentile du temps utilisé par chaque nœud d'index pour encoder les données de champ à chaque fois au cours des deux dernières minutes.p99 :
histogram_quantile(0.99, sum by (le, pod, node_id) (rate(milvus_indexnode_decode_field_latency_bucket{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])))
avg :
sum(increase(milvus_indexnode_decode_field_latency_sum{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])) by(pod, node_id) / sum(increase(milvus_indexnode_decode_field_latency_count{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])) by(pod, node_id)
milvus_indexnode_decode_field_latencyLe temps utilisé pour décoder les données de champ.
Temps de latence de l'index de constructionTemps de latence moyen et 99e percentile du temps utilisé par chaque nœud d'index pour construire les index au cours des deux dernières minutes.p99 :
histogram_quantile(0.99, sum by (le, pod, node_id) (rate(milvus_indexnode_build_index_latency_bucket{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])))
avg :
sum(increase(milvus_indexnode_build_index_latency_sum{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])) by(pod, node_id) / sum(increase(milvus_indexnode_build_index_latency_count{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])) by(pod, node_id)
milvus_indexnode_build_index_latencyLe temps utilisé pour construire les index.
Temps de latence de l'index d'encodageTemps de latence moyen et 99e percentile du temps utilisé par chaque nœud d'index pour encoder les fichiers d'index au cours des deux dernières minutes.p99 :
histogram_quantile(0.99, sum by (le, pod, node_id) (rate(milvus_indexnode_encode_index_latency_bucket{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])))
avg :
sum(increase(milvus_indexnode_encode_index_latency_sum{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])) by(pod, node_id) / sum(increase(milvus_indexnode_encode_index_latency_count{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])) by(pod, node_id)
milvus_indexnode_encode_index_latencyLe temps utilisé pour encoder les fichiers d'index.
Sauvegarder la latence de l'indexTemps de latence moyen et 99e percentile du temps utilisé par chaque nœud d'index pour enregistrer les fichiers d'index au cours des deux dernières minutes.p99 :
histogram_quantile(0.99, sum by (le, pod, node_id) (rate(milvus_indexnode_save_index_latency_bucket{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])))
avg :
sum(increase(milvus_indexnode_save_index_latency_sum{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])) by(pod, node_id) / sum(increase(milvus_indexnode_save_index_latency_count{app_kubernetes_io_instance=~"$instance", app_kubernetes_io_name="$app_name", namespace="$namespace"}[2m])) by(pod, node_id)
milvus_indexnode_save_index_latencyTemps utilisé pour enregistrer les fichiers d'index.

Traduit parDeepLogo

Try Managed Milvus for Free

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

Get Started
Feedback

Cette page a-t - elle été utile ?