Gardien de zoo est un service de coordination distribué et open source pour les applications distribuées. Il expose un ensemble simple de primitives pour implémenter des services de niveau supérieur pour la synchronisation, la maintenance de la configuration, ainsi que le groupe et la dénomination.
Dans un système distribué, plusieurs nœuds ou machines doivent communiquer entre eux et coordonner leurs actions. ZooKeeper fournit un moyen de garantir que ces nœuds se connaissent les uns les autres et peuvent coordonner leurs actions. Pour ce faire, il maintient une arborescence hiérarchique de nœuds de données appelée Znœuds , qui peut être utilisé pour stocker et récupérer des données et conserver les informations d'état. ZooKeeper fournit un ensemble de primitives, telles que des verrous, des barrières et des files d'attente, qui peuvent être utilisées pour coordonner les actions des nœuds dans un système distribué. Il fournit également des fonctionnalités telles que l'élection du leader, le basculement et la récupération, qui peuvent contribuer à garantir la résilience du système face aux pannes. ZooKeeper est largement utilisé dans les systèmes distribués tels que Hadoop, Kafka et HBase, et est devenu un composant essentiel de nombreuses applications distribuées.
Pourquoi en avons-nous besoin?
- Services de coordination : L'intégration/communication de services dans un environnement distribué.
- Les services de coordination sont complexes à mettre en place. Ils sont particulièrement sujets à des erreurs telles que les conditions de concurrence et les blocages.
- Condition de course -Deux systèmes ou plus essayant d'effectuer une tâche.
- Impasses – Deux ou plusieurs opérations s’attendent.
- Pour faciliter la coordination entre les environnements distribués, les développeurs ont eu une idée appelée zookeeper afin de ne pas avoir à décharger les applications distribuées de la responsabilité de mettre en œuvre des services de coordination à partir de zéro.
Qu’est-ce qu’un système distribué ?
- Plusieurs systèmes informatiques travaillant sur un seul problème.
- Il s'agit d'un réseau composé d'ordinateurs autonomes connectés à l'aide d'un middleware distribué.
- Principales caractéristiques : Concurrent, partage de ressources, indépendant, global, plus grande tolérance aux pannes et rapport prix/performance bien meilleur.
- Objectif clé s : Transparence, Fiabilité, Performance, Evolutivité.
- Défis : Sécurité, Défaut, Coordination et partage des ressources.
Défi de coordination
- Pourquoi la coordination dans un système distribué est-elle le problème difficile ?
- Coordination ou gestion de configuration pour une application distribuée comportant de nombreux systèmes.
- Nœud maître où les données du cluster sont stockées.
- Les nœuds travailleurs ou les nœuds esclaves obtiennent les données de ce nœud maître.
- point de défaillance unique.
- la synchronisation n'est pas facile.
- Une conception et une mise en œuvre minutieuses sont nécessaires.
Gardien de zoo Apache
Apache Zookeeper est un service de coordination distribué et open source pour les systèmes distribués. Il fournit un emplacement central permettant aux applications distribuées de stocker des données, de communiquer entre elles et de coordonner leurs activités. Zookeeper est utilisé dans les systèmes distribués pour coordonner les processus et services distribués. Il fournit un modèle de données simple et arborescent, une API simple et un protocole distribué pour garantir la cohérence et la disponibilité des données. Zookeeper est conçu pour être hautement fiable et tolérant aux pannes, et peut gérer des niveaux élevés de débit de lecture et d'écriture.
Zookeeper est implémenté en Java et est largement utilisé dans les systèmes distribués, notamment dans l'écosystème Hadoop. Il s'agit d'un projet Apache Software Foundation et est publié sous la licence Apache 2.0.
Architecture du gardien de zoo
Services de gardien de zoo
L'architecture ZooKeeper se compose d'une hiérarchie de nœuds appelés znodes, organisés selon une structure arborescente. Chaque znode peut stocker des données et dispose d'un ensemble d'autorisations qui contrôlent l'accès au znode. Les znodes sont organisés dans un espace de noms hiérarchique, similaire à un système de fichiers. À la racine de la hiérarchie se trouve le znode racine, et tous les autres znodes sont des enfants du znode racine. La hiérarchie est similaire à une hiérarchie de système de fichiers, dans laquelle chaque znode peut avoir des enfants et des petits-enfants, etc.
Composants importants dans Zookeeper
Services de gardien de zoo
- Leader et suiveur
- Processeur de requête – Actif dans Leader Node et est responsable du traitement des demandes d’écriture. Après traitement, il envoie les modifications aux nœuds suiveurs
- Diffusion atomique – Présent dans les nœuds leader et suiveur. Il est responsable de l'envoi des modifications aux autres nœuds.
- Bases de données en mémoire (Bases de données répliquées) -Il est responsable du stockage des données dans le gardien de zoo. Chaque nœud contient ses propres bases de données. Les données sont également écrites sur le système de fichiers, permettant ainsi une récupération en cas de problème avec le cluster.
Autres composants
- Client – L'un des nœuds de notre cluster d'applications distribuées. Accédez aux informations du serveur. Chaque client envoie un message au serveur pour lui faire savoir que le client est vivant.
- Serveur – Fournit tous les services au client. Donne un accusé de réception au client.
- Ensemble – Groupe de serveurs Zookeeper. Le nombre minimum de nœuds requis pour former un ensemble est de 3.
Modèle de données Zookeeper
Modèle de données ZooKeeper
Dans Zookeeper, les données sont stockées dans un espace de noms hiérarchique, similaire à un système de fichiers. Chaque nœud de l'espace de noms est appelé Znode et peut stocker des données et avoir des enfants. Les Znodes sont similaires aux fichiers et répertoires d'un système de fichiers. Zookeeper fournit une API simple pour créer, lire, écrire et supprimer des Znodes. Il fournit également des mécanismes pour détecter les modifications apportées aux données stockées dans les Znodes, telles que les surveillances et les déclencheurs. Les Znodes maintiennent une structure statistique qui comprend : le numéro de version, l'ACL, l'horodatage et la longueur des données.
Types de nœuds Z :
- Persistance : Vivant jusqu'à ce qu'ils soient explicitement supprimés.
- Éphémère : Actif jusqu'à ce que la connexion client soit active.
- Séquentiel : Soit persistant, soit éphémère.
Pourquoi avons-nous besoin de ZooKeeper dans Hadoop ?
Zookeeper est utilisé pour gérer et coordonner les nœuds d'un cluster Hadoop, y compris NameNode, DataNode et ResourceManager. Dans un cluster Hadoop, Zookeeper permet de :
- Conserver les informations de configuration : Zookeeper stocke les informations de configuration du cluster Hadoop, y compris l'emplacement du NameNode, du DataNode et du ResourceManager.
- Gérer l'état du cluster : Zookeeper suit l'état des nœuds du cluster Hadoop et peut être utilisé pour détecter lorsqu'un nœud est en panne ou devient indisponible.
- Coordonner les processus distribués : Zookeeper peut être utilisé pour coordonner des processus distribués, tels que la planification des tâches et l'allocation des ressources, sur les nœuds d'un cluster Hadoop.
Zookeeper contribue à garantir la disponibilité et la fiabilité d'un cluster Hadoop en fournissant un service de coordination central pour les nœuds du cluster.
Comment fonctionne ZooKeeper dans Hadoop ?
ZooKeeper fonctionne comme un système de fichiers distribué et expose un ensemble simple d'API qui permettent aux clients de lire et d'écrire des données sur le système de fichiers. Il stocke ses données dans une structure arborescente appelée znode, qui peut être considérée comme un fichier ou un répertoire dans un système de fichiers traditionnel. ZooKeeper utilise un algorithme de consensus pour garantir que tous ses serveurs ont une vue cohérente des données stockées dans les Znodes. Cela signifie que si un client écrit des données sur un znode, ces données seront répliquées sur tous les autres serveurs de l'ensemble ZooKeeper.
Une caractéristique importante de ZooKeeper est sa capacité à prendre en charge la notion de montre. Une montre permet à un client de s'inscrire pour recevoir des notifications lorsque les données stockées dans un znode changent. Cela peut être utile pour surveiller les modifications apportées aux données stockées dans ZooKeeper et réagir à ces modifications dans un système distribué.
Dans Hadoop, ZooKeeper est utilisé à diverses fins, notamment :
- Stockage des informations de configuration : ZooKeeper est utilisé pour stocker les informations de configuration partagées par plusieurs composants Hadoop. Par exemple, il peut être utilisé pour stocker les emplacements des NameNodes dans un cluster Hadoop ou les adresses des nœuds JobTracker.
- Assurer une synchronisation distribuée : ZooKeeper est utilisé pour coordonner les activités des différents composants Hadoop et garantir qu'ils fonctionnent ensemble de manière cohérente. Par exemple, il peut être utilisé pour garantir qu'un seul NameNode est actif à la fois dans un cluster Hadoop.
- Gestion des noms : ZooKeeper est utilisé pour maintenir un service de noms centralisé pour les composants Hadoop. Cela peut être utile pour identifier et localiser des ressources dans un système distribué.
ZooKeeper est un composant essentiel de Hadoop et joue un rôle crucial dans la coordination de l'activité de ses différents sous-composants.
Lire et écrire dans Apache Zookeeper
ZooKeeper fournit une interface simple et fiable pour lire et écrire des données. Les données sont stockées dans un espace de noms hiérarchique, similaire à un système de fichiers, avec des nœuds appelés znodes. Chaque znode peut stocker des données et avoir des znodes enfants. Les clients ZooKeeper peuvent lire et écrire des données sur ces znodes en utilisant respectivement les méthodes getData() et setData(). Voici un exemple de lecture et d'écriture de données à l'aide de l'API Java ZooKeeper :
Java
// Connect to the ZooKeeper ensemble> ZooKeeper zk =>new> ZooKeeper(>'localhost:2181'>,>3000>,>null>);> // Write data to the znode '/myZnode'> String path =>'/myZnode'>;> String data =>'hello world'>;> zk.create(path, data.getBytes(), Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);> // Read data from the znode '/myZnode'> byte>[] bytes = zk.getData(path,>false>,>null>);> String readData =>new> String(bytes);> // Prints 'hello world'> System.out.println(readData);> // Closing the connection> // to the ZooKeeper ensemble> zk.close();> |
>
>
Python3
from> kazoo.client>import> KazooClient> # Connect to ZooKeeper> zk>=> KazooClient(hosts>=>'localhost:2181'>)> zk.start()> # Create a node with some data> zk.ensure_path(>'/gfg_node'>)> zk.>set>(>'/gfg_node'>, b>'some_data'>)> # Read the data from the node> data, stat>=> zk.get(>'/gfg_node'>)> print>(data)> # Stop the connection to ZooKeeper> zk.stop()> |
>
stlc
>
Session et veilles
Session
- Les requêtes dans une session sont exécutées dans l’ordre FIFO.
- Une fois la session établie, le ID de session est attribué au client.
- Le client envoie pulsations cardiaques pour que la séance reste valide
- le délai d'expiration de la session est généralement représenté en millisecondes
Montres
- Les montres sont des mécanismes permettant aux clients de recevoir des notifications sur les modifications apportées au Zookeeper.
- Le client peut regarder tout en lisant un znode particulier.
- Les modifications des znodes sont des modifications des données associées aux znodes ou des changements dans les enfants du znode.
- Les montres ne se déclenchent qu'une seule fois.
- Si la session est expirée, les montres sont également supprimées.