TOC

Introduction à Hazelcast Jet

Introduction à Hazelcast Jet

1. introduction

Dans ce didacticiel, nous allons découvrir Hazelcast Jet. Il s’agit d’un moteur de traitement de données distribué fourni par Hazelcast, Inc. et est construit sur le Hazelcast IMDG

Si vous voulez en savoir plus sur Hazelcast IMDG,here est un article pour commencer.

2. Qu'est-ce que Hazelcast Jet?

Hazelcast Jet est un moteur de traitement de données distribué qui traite les données en tant que flux. Il peut traiter des données stockées dans une base de données ou des fichiers, ainsi que des données transmises par un serveur Kafka.

Il peut exécuter des fonctions d'agrégation sur des flux de données infinis en divisant les flux en sous-ensembles et en appliquant une agrégation sur chaque sous-ensemble. Ce concept est appelé "fenêtrage" dans la terminologie Jet.

Nous pouvons déployer Jet dans un cluster de machines, puis lui soumettre nos travaux de traitement de données. Jet fera en sorte que tous les membres du cluster traitent automatiquement les données. Chaque membre du cluster utilise une partie des données, ce qui facilite la mise à niveau vers n'importe quel niveau de débit.

Voici les cas d'utilisation typiques de Hazelcast Jet:

  • Traitement de flux en temps réel

  • Traitement rapide par lots

  • Traitement des flux Java 8 de manière distribuée

  • Traitement de données dans les microservices

3. Installer

Pour configurer Hazelcast Jet dans notre environnement, il suffit d'ajouter une seule dépendance Maven à nospom.xml.

Voici comment nous procédons: 


    com.hazelcast.jet
    hazelcast-jet
    0.6

L'inclusion de cette dépendance téléchargera un fichier jar de 10 Mo qui nous fournira toute l'infrastructure nécessaire pour créer un pipeline de traitement de données distribué.

La dernière version de Hazelcast Jet peut être trouvéehere.

4. Exemple d'application

Afin d'en savoir plus sur Hazelcast Jet, nous allons créer un exemple d'application qui prend une entrée de phrases et un mot à trouver dans ces phrases et renvoie le nombre du mot spécifié dans ces phrases.

4.1. Le pipeline

Un pipeline constitue la construction de base d'une application Jet. Processing within a pipeline follows these steps:

  • tirer des données d'une source

  • transformer les données

  • drainer les données dans un évier

Pour notre application, le pipeline va puiser dans unList distribué, appliquer la transformation de regroupement et d'agrégation et enfin drainer vers unMap distribué.

Voici comment nous écrivons notre pipeline: 

private Pipeline createPipeLine() {
    Pipeline p = Pipeline.create();
    p.drawFrom(Sources. list(LIST_NAME))
      .flatMap(
        word -> traverseArray(word.toLowerCase().split("\\W+")))
      .filter(word -> !word.isEmpty())
      .groupingKey(wholeItem())
      .aggregate(counting())
      .drainTo(Sinks.map(MAP_NAME));
    return p;
}

Une fois que nous avons dessiné à partir de la source, nous parcourons les données et les divisons autour de l'espace à l'aide d'une expression régulière. Après cela, nous filtrons les blancs.

Enfin, nous regroupons les mots, les agrégons et drainons les résultats à unMap. 

4.2. Le travail

Maintenant que notre pipeline est défini, nous créons un travail pour l’exécuter.

Voici comment nous écrivons une fonctioncountWord qui accepte les paramètres et renvoie le nombre: 

public Long countWord(List sentences, String word) {
    long count = 0;
    JetInstance jet = Jet.newJetInstance();
    try {
        List textList = jet.getList(LIST_NAME);
        textList.addAll(sentences);
        Pipeline p = createPipeLine();
        jet.newJob(p)
          .join();
        Map counts = jet.getMap(MAP_NAME);
        count = counts.get(word);
        } finally {
            Jet.shutdownAll();
      }
    return count;
}

Nous créons d’abord une instance Jet afin de créer notre travail et d’utiliser le pipeline. Ensuite, nous copions l’entréeList dans une liste distribuée afin qu’elle soit disponible sur toutes les instances.

Nous soumettons ensuite un travail en utilisant le pipeline que nous avons construit ci-dessus. La méthodenewJob() renvoie un travail exécutable qui est démarré par Jet de manière asynchrone. La méthodejoin attend la fin du travail et renvoie unexception si le travail est terminé avec une erreur.

Lorsque le travail est terminé, les résultats sont récupérés dans unMap,  distribué que nous avons défini dans notre pipeline. Ainsi, nous obtenons lesMap de l'instance Jet et obtenons le nombre de mots correspondants.

Enfin, nous avons fermé l'instance Jet. Il est important de l'arrêter une fois notre exécution terminée, commeJet instance starts its own threads. Sinon, notre processus Java sera toujours actif, même après la fin de notre méthode.

Voici un test unitaire qui teste le code que nous avons écrit pour Jet: 

@Test
public void whenGivenSentencesAndWord_ThenReturnCountOfWord() {
    List sentences = new ArrayList<>();
    sentences.add("The first second was alright, but the second second was tough.");
    WordCounter wordCounter = new WordCounter();
    long countSecond = wordCounter.countWord(sentences, "second");
    assertTrue(countSecond == 3);
}

5. Conclusion

Dans cet article, nous avons découvert Hazelcast Jet. Pour en savoir plus sur celui-ci et ses fonctionnalités, reportez-vous auxmanual.

Comme d'habitude, le code de l'exemple utilisé dans cet article se trouveover on Github.

Related