Données de journal avec Flume dans HDFS - mannequins

Certaines données qui finissent dans le système de fichiers distribués Hadoop (HDFS) peuvent y atterrir via des opérations de chargement de base de données ou d'autres types de traitement par lots. si vous souhaitez capturer les données qui circulent dans les flux de données à haut débit, telles que les données du journal des applications? Apache Flume est la méthode standard actuelle pour le faire facilement, efficacement et en toute sécurité.

Apache Flume , un autre projet de plus haut niveau d'Apache Software Foundation, est un système distribué permettant d'agréger et de déplacer de grandes quantités de données en continu de différentes sources vers un magasin de données centralisé.

Autrement dit, Flume est conçu pour l'ingestion continue de données dans HDFS. Les données peuvent être n'importe quel type de données, mais Flume est particulièrement bien adapté à la gestion des données de journal, telles que les données de journal des serveurs Web. Les unités des données traitées par Flume sont appelées événements ; un exemple d'événement est un enregistrement de journal.

Pour comprendre le fonctionnement de Flume dans un cluster Hadoop, vous devez savoir que Flume s'exécute sous la forme d'un ou de plusieurs agents et que chaque agent dispose de trois composants enfichables: sources, canaux et récepteurs:

• Les sources récupèrent les données et les envoient aux canaux.

• Les canaux contiennent des files d'attente de données et servent de canaux entre les sources et les puits, ce qui est utile lorsque le débit entrant dépasse le débit sortant.

• Les puits traitent les données provenant des canaux et les transmettent à une destination, telle que HDFS.

  

Un agent doit avoir au moins un composant à exécuter et chaque agent est contenu dans sa propre instance de la machine virtuelle Java (JVM).

Un événement qui est écrit sur un canal par une source n'est pas supprimé de ce canal jusqu'à ce qu'un collecteur le supprime au moyen d'une transaction. Si une panne réseau se produit, les canaux conservent leurs événements en file d'attente jusqu'à ce que les récepteurs puissent les écrire sur le cluster. Un canal en mémoire peut traiter les événements rapidement, mais il est volatile et ne peut pas être récupéré, alors qu'un canal basé sur un fichier offre une persistance et peut être récupéré en cas de défaillance.

Chaque agent peut avoir plusieurs sources, canaux et récepteurs, et bien qu'une source puisse écrire sur de nombreux canaux, un récepteur peut prendre des données d'un seul canal.

Un agent est simplement une machine virtuelle Java exécutant Flume et les puits de chaque noeud d'agent dans le cluster Hadoop envoient des données aux nœuds de collecteur , qui regroupent les données de plusieurs agents avant l'écrire dans HDFS, où il peut être analysé par d'autres outils Hadoop. Les agents peuvent être chaînés de sorte que le récepteur d'un agent envoie des données à la source à partir d'un autre agent.Avro, le framework d'appel et de sérialisation à distance d'Apache, est la manière habituelle d'envoyer des données sur un réseau avec Flume, car il sert d'outil utile pour la sérialisation ou la transformation efficace des données dans un format binaire compact.

Dans le contexte de Flume, la compatibilité est importante: Un événement Avro nécessite une source Avro, par exemple, et un récepteur doit fournir les événements appropriés à la destination.

La configuration de l'agent Flume, qui est stockée dans un fichier texte local structuré comme un fichier de propriétés Java, constitue le fil conducteur de cette grande chaîne de sources, de canaux et de puits. Vous pouvez configurer plusieurs agents dans le même fichier. Regardez un exemple de fichier, nommé flume-agent. conf - configuré pour configurer un agent nommé shaman:

# Identifie les composants sur l'agent shaman: chaman. sources = chaman netcat_s1. puits = hdfs_w1 shaman. channels = in-mem_c1 # Configure la source: chaman. sources. netcat_s1. type = netcat chaman. sources. netcat_s1. bind = chaman localhost. sources. netcat_s1. port = 44444 # Décrivez l'évier: chaman. puits hdfs_w1. type = hdfs chaman. puits hdfs_w1. hdfs. chemin = hdfs: // chaman. puits hdfs_w1. hdfs. writeFormat = Chaman de texte. puits hdfs_w1. hdfs. fileType = DataStream # Configure un canal qui met en mémoire tampon les événements en mémoire: chaman. canaux. in-mem_c1. type = chaman mémoire. canaux. in-mem_c1. capacité = 20000 chaman. canaux. in-mem_c1. transactionCapacity = 100 # Liez la source et le puits au canal: chaman. sources. netcat_s1. channels = chaman in-mem_c1. puits hdfs_w1. channels = in-mem_c1

Le fichier de configuration inclut des propriétés pour chaque source, canal et récepteur de l'agent et spécifie comment ils sont connectés. Dans cet exemple, l'agent shaman a une source qui écoute les données (messages à netcat) sur le port 44444, un canal qui met en mémoire tampon les données d'événement en mémoire et un récepteur qui enregistre les données d'événement dans la console.

Ce fichier de configuration aurait pu être utilisé pour définir plusieurs agents; Ici, vous en configurez un seul pour garder les choses simples.

Pour démarrer l'agent, utilisez un script shell appelé flume-ng, situé dans le répertoire bin de la distribution Flume. À partir de la ligne de commande, émettez la commande d'agent en spécifiant le chemin d'accès au fichier de configuration et le nom de l'agent.

L'exemple de commande suivant démarre l'agent Flume:

flume-ng agent -f / -n shaman

Le journal de l'agent Flume doit contenir des entrées vérifiant que la source, le canal et le récepteur ont bien démarré.

Pour tester la configuration, vous pouvez utiliser telnet sur le port 44444 d'un autre terminal et envoyer un événement à Flume en entrant une chaîne de caractères arbitraire. Si tout se passe bien, le terminal Flume d'origine affichera l'événement dans un message de journal que vous devriez pouvoir voir dans le journal de l'agent.