Éclats et répliques dans Elasticsearch

J'essaie de comprendre ce qu'est un fragment et une réplique dans Elasticsearch, mais je n'ai pas réussi à le comprendre. Si je télécharge Elasticsearch et exécute le script, à partir de ce que je sais, j'ai démarré un cluster avec un seul nœud. Maintenant, ce nœud (mon PC) a 5 fragments (?) Et quelques répliques (?).

Quels sont-ils, ai-je 5 doublons de l'index? Si oui, pourquoi? Je pourrais avoir besoin d'explications.

Je vais essayer d'expliquer avec un vrai exemple car la réponse et les réponses que vous avez obtenues ne semblent pas vous aider.

Lorsque vous téléchargez elasticsearch et démarrez-le, vous créez un noeud elasticsearch qui essaie de rejoindre un cluster existant s'il est disponible ou en crée un nouveau. Supposons que vous ayez créé votre propre nouveau cluster avec un seul nœud, celui que vous venez de démarrer. Nous n'avons pas de données, nous devons donc créer un index.

Lorsque vous créez un index (un index est automatiquement créé lorsque vous indexez également le premier document), vous pouvez définir le nombre de fragments qui le composera. Si vous ne spécifiez pas de nombre, il aura le nombre de fragments par défaut: 5 primaires. Qu'est-ce que ça veut dire?

Cela signifie qu'elasticsearch créera 5 fragments principaux qui contiendront vos données:

 ____    ____    ____    ____    ____
| 1  |  | 2  |  | 3  |  | 4  |  | 5  |
|____|  |____|  |____|  |____|  |____|

Chaque fois que vous indexez un document, elasticsearch décidera quel fragment principal est censé contenir ce document et l'indexera là. Les fragments primaires ne sont pas une copie des données, ce sont les données! Avoir plusieurs fragments aide à tirer parti du traitement parallèle sur une seule machine, mais le fait est que si nous démarrons une autre instance elasticsearch sur le même cluster, les fragments seront distribués de manière uniforme sur le cluster.

Le nœud 1 ne contiendra alors par exemple que trois fragments:

 ____    ____    ____ 
| 1  |  | 2  |  | 3  |
|____|  |____|  |____|

Étant donné que les deux fragments restants ont été déplacés vers le nœud nouvellement démarré:

 ____    ____
| 4  |  | 5  |
|____|  |____|

Pourquoi cela arrive-t-il? Parce qu'elasticsearch est un moteur de recherche distribué et de cette façon, vous pouvez utiliser plusieurs nœuds / machines pour gérer de grandes quantités de données.

Chaque index elasticsearch est composé d'au moins un fragment principal, car c'est là que les données sont stockées. Chaque fragment a un coût, cependant, donc si vous avez un seul nœud et aucune croissance prévisible, restez avec un seul fragment principal.

Un autre type de fragment est une réplique. La valeur par défaut est 1, ce qui signifie que chaque fragment principal sera copié dans un autre fragment qui contiendra les mêmes données. Les répliques sont utilisées pour augmenter les performances de recherche et pour le basculement. Un fragment de réplique ne sera jamais alloué sur le même noeud où se trouve le primaire associé (ce serait à peu près comme mettre une sauvegarde sur le même disque que les données d'origine).

Revenons à notre exemple, avec 1 réplique, nous aurons l'index entier sur chaque nœud, car 2 fragments de réplique seront alloués sur le premier nœud et ils contiendront exactement les mêmes données que les fragments principaux sur le deuxième nœud:

 ____    ____    ____    ____    ____
| 1  |  | 2  |  | 3  |  | 4R |  | 5R |
|____|  |____|  |____|  |____|  |____|

Idem pour le deuxième nœud, qui contiendra une copie des fragments principaux sur le premier nœud:

 ____    ____    ____    ____    ____
| 1R |  | 2R |  | 3R |  | 4  |  | 5  |
|____|  |____|  |____|  |____|  |____|

Avec une configuration comme celle-ci, si un nœud tombe en panne, vous avez toujours l'index entier. Les fragments de réplique deviendront automatiquement des éléments primaires et le cluster fonctionnera correctement malgré la défaillance du nœud, comme suit:

 ____    ____    ____    ____    ____
| 1  |  | 2  |  | 3  |  | 4  |  | 5  |
|____|  |____|  |____|  |____|  |____|

Comme vous l'avez déjà fait "number_of_replicas":1, les répliques ne peuvent plus être affectées car elles ne sont jamais allouées sur le même nœud que leur principal. C'est pourquoi vous aurez 5 fragments non attribués, les répliques et l'état du cluster seront à la YELLOWplace de GREEN. Aucune perte de données, mais cela pourrait être mieux car certains fragments ne peuvent pas être attribués.

Dès que le nœud restant est sauvegardé, il rejoint à nouveau le cluster et les répliques sont à nouveau attribuées. Le fragment existant sur le deuxième nœud peut être chargé, mais ils doivent être synchronisés avec les autres fragments, car les opérations d'écriture se sont probablement produites alors que le nœud était en panne. À la fin de cette opération, l'état du cluster deviendra GREEN.

J'espère que cela clarifie les choses pour vous.

Un index est divisé en fragments afin de les distribuer et de les mettre à l'échelle.

Les répliques sont des copies des fragments et offrent une fiabilité en cas de perte d'un nœud. Il y a souvent de la confusion dans ce nombre car le nombre de répliques == 1 signifie que le cluster doit avoir la copie principale et répliquée du fragment disponible pour être à l'état vert.

Pour que des répliques soient créées, vous devez avoir au moins 2 nœuds dans votre cluster.

Vous pouvez trouver les définitions ici plus faciles à comprendre: http://www.elasticsearch.org/guide/reference/glossary/

Cordialement, Paul

Si vous n'aimez vraiment pas le voir jaune. vous pouvez définir le nombre de répliques à zéro:

curl -XPUT 'localhost:9200/_settings' -d '
{
    "index" : {
        "number_of_replicas" : 0
    }
}
'

Notez que vous ne devez le faire que sur votre boîte de développement locale.

Tesson:

1. Étant un serveur de recherche distribué, ElasticSearchutilise le concept appelé Shardpour distribuer les documents d'index sur tous les nœuds.
2. Un indexpeut potentiellement stocker une grande quantité de données pouvant dépasser les limites matérielles d'unsingle node
3. Par exemple, un index unique d'un milliard de documents occupant 1 To d'espace disque peut ne pas tenir sur le disque d'un seul nœud ou peut être trop lent pour répondre aux demandes de recherche d'un seul nœud.
4. Pour résoudre ce problème, Elasticsearchoffre la possibilité de subdiviser votre index en plusieurs morceaux appelés shards.
5. Lorsque vous créez un index, vous pouvez simplement définir le nombre shards souhaité.
6. Documentssont stockés dans shards, et les fragments sont alloués à nodesdans votrecluster
7. Au clusterfur et à mesure que votre croissance ou rétrécissement, Elasticsearchmigrera automatiquement les fragments entre nodesafin que le clusterreste reste équilibré.
8. Un éclat peut être un primary shardou un replica shard.
9. Chaque document de votre index appartient à un single primary shard, donc le nombre de fragments principaux que vous avez détermine la quantité maximale de données que votre index peut contenir
10. A replica shardn'est qu'une copie d'un fragment principal.

Réplique:

1. Replica shardest la copie de primary Shard, pour éviter la perte de données en cas de panne matérielle.
2. Elasticsearchvous permet de faire une ou plusieurs copies des fragments de votre index en ce que l'on appelle des fragments de réplique, ou replicaspour faire court.
3. Un indexpeut également être répliqué zéro (ce qui signifie pas de répliques) ou plusieurs fois.
4. Les number of shardsrépliques et peuvent être définies par index au moment de la création de l'index.
5. Une fois l'index créé, vous pouvez modifier le nombre de répliques de manière dynamique à tout moment, mais vous cannot change the number of shards après coup.
6. Par défaut, chaque index dans Elasticsearchse voit allouer 5 fragments principaux, 1 replicace qui signifie que si vous avez au moins deux nœuds dans votre cluster, votre index aura 5 fragments principaux et 5 autres fragments de réplique (1 réplique complète) pour un total de 10 fragments par indice.

Un index est divisé en fragments afin de les distribuer et de les mettre à l'échelle.

Les répliques sont des copies des fragments.

Un nœud est une instance en cours de recherche élastique qui appartient à un cluster.

Un cluster se compose d'un ou plusieurs nœuds qui partagent le même nom de cluster. Chaque cluster a un seul nœud maître qui est choisi automatiquement par le cluster et qui peut être remplacé en cas de défaillance du nœud maître actuel.

Je vais expliquer cela en utilisant un vrai scénario de mots. Imaginez que vous dirigez un site Web de commerce électronique. À mesure que vous devenez plus populaire, plus de vendeurs et de produits s'ajoutent à votre site Web. Vous vous rendrez compte que le nombre de produits que vous pourriez avoir besoin d'indexer a augmenté et qu'il est trop grand pour tenir dans un disque dur d'un nœud. Même s'il tient dans le disque dur, effectuer une recherche linéaire à travers tous les documents sur une seule machine est extrêmement lent. un index sur un nœud ne bénéficiera pas de la configuration de cluster distribué sur laquelle fonctionne elasticsearch.

Elasticsearch répartit donc les documents de l'index sur plusieurs nœuds du cluster. Chaque fractionnement du document est appelé un fragment. Chaque nœud portant un fragment d'un document n'aura qu'un sous-ensemble du document. supposons que vous ayez 100 produits et 5 fragments, chaque fragment aura 20 produits. Ce partage des données rend possible la recherche à faible latence dans elasticsearch. la recherche est effectuée en parallèle sur plusieurs nœuds. Les résultats sont agrégés et renvoyés. Cependant, les fragments ne fournissent pas de tolérance aux pannes. Cela signifie que si un nœud contenant le fragment est en panne, la santé du cluster devient jaune. Cela signifie que certaines données ne sont pas disponibles.

Pour augmenter la tolérance aux pannes, les répliques entrent en image. Par deault, la recherche élastique crée une réplique unique de chaque fragment. Ces répliques sont toujours créées sur un autre nœud où le fragment principal ne réside pas. Donc, pour rendre le système tolérant aux pannes, vous devrez peut-être augmenter le nombre de nœuds dans votre cluster et cela dépend également du nombre de fragments de votre index. La formule générale pour calculer le nombre de nœuds requis en fonction des répliques et des fragments est "nombre de nœuds = nombre de fragments * (nombre de répliques + 1)". La pratique standard est d'avoir au moins une réplique pour la tolérance aux pannes.

La configuration du nombre de fragments est une opération statique, ce qui signifie que vous devez le spécifier lorsque vous créez un index. Tout changement après cela nécessitera une réindexation complète des données et prendra du temps. Mais, la configuration du nombre de répliques est une opération dynamique et peut également être effectuée à tout moment après la création de l'index.

vous pouvez configurer le nombre de fragments et de répliques pour votre index avec la commande ci-dessous.

curl -XPUT 'localhost:9200/sampleindex?pretty' -H 'Content-Type: application/json' -d '
{
  "settings":{
    "number_of_shards":2,
    "number_of_replicas":1
  }
}'

Pas une réponse mais une autre référence pour les concepts de base à ElasticSearch, et je pense qu'ils sont assez clairs en complément de la réponse de @ javanna.

Fragments

Un index peut potentiellement stocker une grande quantité de données pouvant dépasser les limites matérielles d'un seul nœud. Par exemple, un index unique d'un milliard de documents occupant 1 To d'espace disque peut ne pas tenir sur le disque d'un seul nœud ou peut être trop lent pour répondre aux demandes de recherche d'un seul nœud.

Pour résoudre ce problème, Elasticsearch offre la possibilité de subdiviser votre index en plusieurs morceaux appelés fragments. Lorsque vous créez un index, vous pouvez simplement définir le nombre de fragments que vous souhaitez. Chaque fragment est en soi un "index" entièrement fonctionnel et indépendant qui peut être hébergé sur n'importe quel nœud du cluster.

Le sharding est important pour deux raisons principales:

• Il vous permet de diviser / mettre à l'échelle horizontalement votre volume de contenu.
• Il vous permet de distribuer et de paralléliser les opérations entre les fragments (potentiellement sur plusieurs nœuds), augmentant ainsi les performances / le débit .

Les répliques

Dans un environnement réseau / cloud où des pannes peuvent être attendues à tout moment, il est très utile et fortement recommandé d'avoir un mécanisme de basculement dans le cas où un fragment / nœud se déconnecte ou disparaît pour une raison quelconque. À cette fin, Elasticsearch vous permet de faire une ou plusieurs copies des fragments de votre index en ce que l'on appelle des fragments de réplique, ou des répliques en abrégé.

La réplication est importante pour deux raisons principales:

• Il offre une haute disponibilité en cas de défaillance d'un fragment / nœud. Pour cette raison, il est important de noter qu'un fragment de réplique n'est jamais alloué sur le même nœud que le fragment d'origine / principal à partir duquel il a été copié.
• Il vous permet de mettre à l' échelle votre volume / débit de recherche, car les recherches peuvent être exécutées en parallèle sur toutes les répliques.

Dans ElasticSearch, au niveau supérieur, nous indexons les documents dans des index. Chaque index a un certain nombre de fragments qui distribuent en interne les données et à l'intérieur des fragments existent les segments Lucene qui est le stockage de base des données. Donc, si l'index a 5 fragments, cela signifie que les données ont été réparties entre les fragments et qu'il n'y a pas les mêmes données dans les fragments.

Attention à la vidéo qui explique le cœur de l'ES https://www.youtube.com/watch?v=PpX7J-G2PEo

Article sur plusieurs index ou plusieurs fragments Recherche élastique, plusieurs index vs un seul index et types pour différents ensembles de données?

Elasticsearch est extrêmement évolutif avec tout le mérite de son architecture distribuée. Il est rendu possible grâce à Sharding. Maintenant, avant d'aller plus loin, considérons un cas d'utilisation simple et très courant. Supposons que vous ayez un index qui contient beaucoup de documents, et pour des raisons de simplicité, considérez que la taille de cet index est de 1 To (c'est-à-dire que la somme des tailles de chaque document de cet index est de 1 To ). Supposons également que vous disposez de deux nœuds avec chacun 512 Go d'espace disponible pour le stockage des données. Comme on peut le voir clairement, notre index complet ne peut être stocké dans aucun des deux nœuds disponibles et nous devons donc répartir notre index entre ces nœuds.

Dans des cas comme celui-ci où la taille d'un index dépasse les limites matérielles d'un seul nœud, Sharding vient à la rescousse. Sharding résout ce problème en divisant les indices en morceaux plus petits et ces morceaux sont nommés Shards.

Dans ses termes les plus simples, le shardn'est rien d'autre qu'une partie d'un index stocké sur le disque dans un dossier séparé:

Cette capture d'écran montre l'intégralité du répertoire Elasticsearch.

Comme vous pouvez le voir, toutes les données vont dans le datarépertoire.

En inspectant l'index, C-mAfLltQzuas72iMiIXNwnous voyons qu'il a cinq fragments (dossiers 0vers 4).

En revanche, l' JH_A8PgCRj-GK0GeQ0limwindex n'a qu'un seul fragment ( 0dossier).

Le privues le nombre total de tessons.