Programmation de flux de données avec paille

La programmation de flux de données, un modèle informatique classique, connaît un renouveau grâce à la surtension des services en temps réel à l'échelle Web. Sa simplicité inhérente, son évolutivité et sa efficacité des ressources le rendent idéal pour de nombreux défis d'ingénierie. Straw, un cadre Node.js, facilite la mise en œuvre du flux de données, conçu à l'origine pour le traitement des données financières en temps réel et capable de gérer des milliers de messages par seconde sur le matériel modeste.

Code de structures de paille en nœuds interconnectés: chaque nœud reçoit l'entrée, le traite et produit les résultats. Cette conception modulaire simplifie des problèmes complexes, améliorant l'évolutivité et la résilience. Cet article démontre les capacités de Straw en détaillant son application dans l'exploitation de tirs de Twitter pour les données de tweet. Le processus consiste à configurer des nœuds pour ingérer des données brutes, effectuer une analyse et distribuer des résultats à un serveur express et aux clients via les lignes Web pour une visualisation en temps réel.

Introduction à la paille et à la botte de foin

La paille définit une topologie des nœuds, chacun avec entrée et zéro ou plus de sorties. Les nœuds traitent les messages entrants à l'aide de fonctions définies par l'utilisateur, générant des messages de sortie pour les nœuds connectés. L'exemple d'application, la back de foin, implique des nœuds pour la consommation de données brutes à partir du filage de feu, le routage des données pour l'analyse et les nœuds d'analyse eux-mêmes. Les données sont ensuite relayées sur un serveur express et des clients via WebSockets. Pour suivre, installez la back de foin localement; Redis et Bower sont des conditions préalables. Installation de Bower: npm install -g bower. Clonage et configuration de la back de foin:

git clone https://github.com/simonswain/haystack
cd haystack
npm install
bower install

Exécution du flux de données Firehose

L'accès au twitter Firehose nécessite des informations d'identification API obtenues en créant une application Twitter (Lire les autorisations uniquement). Obtenez le consumer_key, consumer_secret, access_token_key et access_token_secret dans l'onglet Keys API. Mettez à jour le fichier de configuration de l'exemple de configuration de Haystack (config.js) avec vos informations d'identification:

exports.twitter = {
  consumer_key: '{your consumer key}',
  consumer_secret: '{your consumer secret}',
  access_token_key: '{your access token key}',
  access_token_secret: '{your access token secret}'
};

Exécutez la botte de foin à l'aide de deux terminaux distincts: un pour la topologie de paille (node run), et un autre pour le serveur express (node server.js). Accéder à la visualisation à http://localhost:3000.

Comprendre la topologie de paille (run.js)

run.js définit la topologie de paille. Les nœuds et leurs connexions sont spécifiés dans un objet. Par exemple:

var topo = new straw.topology({
  'consume-firehose': {
    'node': __dirname + '/nodes/consume-firehose.js',
    'output': 'raw-tweets',
    'twitter': config.twitter
  },
  'route-tweets': {
    'node': __dirname + '/nodes/route-tweets.js',
    'input': 'raw-tweets',
    'outputs': {
      'geo': 'client-geo',
      'lang': 'lang',
      'text': 'text'
    }
  },
  // ... more nodes
});

Les nœuds

sont situés dans le répertoire nodes. consume-firehose (aucune entrée) introduit des messages; route-tweets montre plusieurs sorties pour le routage de messages sélectifs.

Exemples de nœuds (Consume-FireHose.js et Route-Tweets.js)

consume-firehose.js:

// nodes/consume-firehose.js
var straw = require('straw');
var Twitter = require('twitter');

module.exports = straw.node.extend({
  initialize: function(opts, done) {
    this.twit = new Twitter(opts.twitter);
    process.nextTick(done);
  },
  run: function(done) {
    var self = this;
    this.twit.stream('statuses/sample', function(stream) {
      stream.on('data', function(data) {
        self.output(data);
      });
    });
    done(false);
  }
});

route-tweets.js:

git clone https://github.com/simonswain/haystack
cd haystack
npm install
bower install

Le nœud Catch-Langs (pour l'agrégation du langage)

catch-langs Les comptes de langage agrégées, émettant périodiquement des totaux pour éviter des clients écrasants. Il utilise setInterval pour contrôler les émissions, l'incréation des dénombrements du langage et l'émission de totaux lorsque des changements se produisent.

Le serveur express (serveur.js) et la visualisation côté client (haystack.js)

server.js utilise express et socket.io (ou sockjs) pour servir l'interface Web et diffuser des données à partir de la paille à l'aide d'un straw.tap. Le côté client (public/js/haystack.js) reçoit et visualise ces données.

Conclusion

Haystack illustre le traitement du flux de données pour les flux de données en temps réel. Le parallélisme et la modularité inhérents de la paille simplifient les tâches complexes. Étendre la botte de foin en ajoutant des nœuds et des visualisations.

Questions fréquemment posées (FAQ) sur la programmation de flux de données (Cette section reste largement inchangée de l'entrée, car il s'agit d'une section FAQ autonome.) Les FAQ fournies sont complets et bien écrits et Don ' T nécessite une modification aux fins de cette réécriture.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!