Apache Flink - Guide rapide

La progression des données au cours des 10 dernières années a été énorme; cela a donné naissance à un terme «Big Data». Il n'y a pas de taille fixe de données, que vous pouvez appeler Big Data; toutes les données que votre système traditionnel (SGBDR) n'est pas capable de gérer sont du Big Data. Ce Big Data peut être au format structuré, semi-structuré ou non structuré. Au départ, les données comportaient trois dimensions: volume, vitesse, variété. Les dimensions sont maintenant allées au-delà des trois Vs. Nous avons maintenant ajouté d'autres V - véracité, validité, vulnérabilité, valeur, variabilité, etc.

Le Big Data a conduit à l'émergence de multiples outils et cadres qui aident au stockage et au traitement des données. Il existe quelques frameworks Big Data populaires tels que Hadoop, Spark, Hive, Pig, Storm et Zookeeper. Cela a également permis de créer des produits Next Gen dans plusieurs domaines tels que la santé, la finance, la vente au détail, le commerce électronique, etc.

Qu'il s'agisse d'un MNC ou d'une start-up, tout le monde utilise le Big Data pour le stocker et le traiter et prendre des décisions plus intelligentes.

En termes de Big Data, il existe deux types de traitement -

Le traitement par lots
Traitement en temps réel

Le traitement basé sur les données collectées au fil du temps est appelé traitement par lots. Par exemple, un directeur de banque souhaite traiter les données d'un mois passé (collectées au fil du temps) pour connaître le nombre de chèques qui ont été annulés au cours du dernier mois.

Le traitement basé sur des données immédiates pour un résultat instantané est appelé traitement en temps réel. Par exemple, un directeur de banque reçoit une alerte de fraude immédiatement après qu'une transaction frauduleuse (résultat instantané) s'est produite.

Le tableau ci-dessous répertorie les différences entre le traitement par lots et le traitement en temps réel -

Le traitement par lots	Traitement en temps réel
Fichiers statiques	Flux d'événements
Traités périodiquement en minute, heure, jour, etc.	Traité immédiatement nanosecondes
Données antérieures sur le stockage sur disque	En mémoire
Exemple - Génération de factures	Exemple - Alerte de transaction ATM

De nos jours, le traitement en temps réel est beaucoup utilisé dans chaque organisation. Les cas d'utilisation tels que la détection de fraude, les alertes en temps réel dans les soins de santé et les alertes d'attaque réseau nécessitent un traitement en temps réel des données instantanées; un retard même de quelques millisecondes peut avoir un impact énorme.

Un outil idéal pour de tels cas d'utilisation en temps réel serait celui qui peut entrer des données sous forme de flux et non de lots. Apache Flink est cet outil de traitement en temps réel.

Apache Flink est un cadre de traitement en temps réel qui peut traiter des données en continu. Il s'agit d'un cadre de traitement de flux open source pour des applications en temps réel hautes performances, évolutives et précises. Il a un véritable modèle de streaming et ne prend pas les données d'entrée sous forme de lots ou de micro-lots.

Apache Flink a été fondé par la société Data Artisans et est maintenant développé sous licence Apache par Apache Flink Community. Cette communauté compte plus de 479 contributeurs et plus de 15500 commits à ce jour.

Écosystème sur Apache Flink

Le diagramme ci-dessous montre les différentes couches de l'écosystème Apache Flink -

Espace de rangement

Apache Flink dispose de plusieurs options à partir desquelles il peut lire / écrire des données. Voici une liste de stockage de base -

HDFS (système de fichiers distribué Hadoop)
Système de fichiers local
S3
SGBDR (MySQL, Oracle, MS SQL, etc.)
MongoDB
HBase
Apache Kafka
Apache Flume

Déployer

Vous pouvez déployer Apache Fink en mode local, en mode cluster ou sur le cloud. Le mode cluster peut être autonome, YARN, MESOS.

Sur le cloud, Flink peut être déployé sur AWS ou GCP.

Noyau

Il s'agit de la couche d'exécution, qui fournit le traitement distribué, la tolérance aux pannes, la fiabilité, la capacité de traitement itératif natif, etc.

API et bibliothèques

Il s'agit de la couche supérieure et de la couche la plus importante d'Apache Flink. Il dispose de l'API Dataset, qui s'occupe du traitement par lots, et de l'API Datastream, qui s'occupe du traitement des flux. Il existe d'autres bibliothèques telles que Flink ML (pour l'apprentissage automatique), Gelly (pour le traitement des graphiques), Tables pour SQL. Cette couche fournit diverses capacités à Apache Flink.

Apache Flink fonctionne sur l'architecture Kappa. L'architecture Kappa a un seul processeur - flux, qui traite toutes les entrées comme des flux et le moteur de streaming traite les données en temps réel. Les données par lots dans l'architecture kappa sont un cas particulier de streaming.

Le diagramme suivant montre le Apache Flink Architecture.

L'idée clé de l'architecture Kappa est de gérer à la fois les données par lots et en temps réel via un seul moteur de traitement de flux.

La plupart des frameworks Big Data fonctionnent sur l'architecture Lambda, qui dispose de processeurs séparés pour les données par lots et en continu. Dans l'architecture Lambda, vous disposez de bases de code distinctes pour les vues par lots et par flux. Pour interroger et obtenir le résultat, les bases de code doivent être fusionnées. Ne pas maintenir des bases de code / vues séparées et les fusionner est une douleur, mais l'architecture Kappa résout ce problème car elle n'a qu'une seule vue - en temps réel, donc la fusion de la base de code n'est pas nécessaire.

Cela ne signifie pas que l'architecture Kappa remplace l'architecture Lambda, cela dépend complètement du cas d'utilisation et de l'application qui décide quelle architecture serait préférable.

Le diagramme suivant illustre l'architecture d'exécution des tâches Apache Flink.

Programme

C'est un morceau de code que vous exécutez sur le cluster Flink.

Client

Il est chargé de prendre le code (programme) et de construire le graphique de flux de données de travail, puis de le transmettre à JobManager. Il récupère également les résultats du travail.

JobManager

Après avoir reçu le graphique Job Dataflow du client, il est responsable de la création du graphique d'exécution. Il attribue le travail aux TaskManagers du cluster et supervise l'exécution du travail.

Gestionnaire des tâches

Il est responsable de l'exécution de toutes les tâches qui ont été assignées par JobManager. Tous les TaskManagers exécutent les tâches dans leurs emplacements séparés dans un parallélisme spécifié. Il est responsable d'envoyer l'état des tâches à JobManager.

Caractéristiques d'Apache Flink

Les fonctionnalités d'Apache Flink sont les suivantes -

Il dispose d'un processeur de streaming, qui peut exécuter des programmes par lots et par flux.
Il peut traiter les données à une vitesse fulgurante.
API disponibles en Java, Scala et Python.
Fournit des API pour toutes les opérations courantes, ce qui est très facile à utiliser pour les programmeurs.
Traite les données avec une faible latence (nanosecondes) et un débit élevé.
Son tolérant aux fautes. Si un nœud, une application ou un matériel tombe en panne, cela n'affecte pas le cluster.
Peut facilement s'intégrer à Apache Hadoop, Apache MapReduce, Apache Spark, HBase et d'autres outils Big Data.
La gestion en mémoire peut être personnalisée pour un meilleur calcul.
Il est hautement évolutif et peut évoluer jusqu'à des milliers de nœuds dans un cluster.
Le fenêtrage est très flexible dans Apache Flink.
Fournit des bibliothèques de traitement graphique, d'apprentissage automatique et de traitement d'événements complexes.

Voici la configuration système requise pour télécharger et travailler sur Apache Flink -

Système d'exploitation recommandé

Microsoft Windows 10
Ubuntu 16.04 LTS
Apple macOS 10.13 / High Sierra

Mémoire nécessaire

Mémoire - Minimum 4 Go, recommandé 8 Go
Espace de stockage - 30 Go

Note - Java 8 doit être disponible avec des variables d'environnement déjà définies.

Avant de commencer la configuration / l'installation d'Apache Flink, vérifions si Java 8 est installé dans notre système.

Java - version

Nous allons maintenant procéder en téléchargeant Apache Flink.

wget http://mirrors.estointernet.in/apache/flink/flink-1.7.1/flink-1.7.1-bin-scala_2.11.tgz

Maintenant, décompressez le fichier tar.

tar -xzf flink-1.7.1-bin-scala_2.11.tgz

Allez dans le répertoire personnel de Flink.

cd flink-1.7.1/

Démarrez le cluster Flink.

./bin/start-cluster.sh

Ouvrez le navigateur Mozilla et accédez à l'URL ci-dessous, cela ouvrira le tableau de bord Web Flink.

http://localhost:8081

Voici à quoi ressemble l'interface utilisateur d'Apache Flink Dashboard.

Le cluster Flink est maintenant opérationnel.

Flink dispose d'un riche ensemble d'API à l'aide desquelles les développeurs peuvent effectuer des transformations à la fois sur des données par lots et en temps réel. Une variété de transformations comprend le mappage, le filtrage, le tri, la jonction, le regroupement et l'agrégation. Ces transformations par Apache Flink sont effectuées sur des données distribuées. Parlons des différentes API qu'offre Apache Flink.

API de l'ensemble de données

L'API de jeu de données dans Apache Flink est utilisée pour effectuer des opérations par lots sur les données sur une période. Cette API peut être utilisée en Java, Scala et Python. Il peut appliquer différents types de transformations sur les ensembles de données comme le filtrage, le mappage, l'agrégation, la jonction et le regroupement.

Les ensembles de données sont créés à partir de sources telles que des fichiers locaux ou en lisant un fichier à partir d'une source particulière et les données de résultat peuvent être écrites sur différents puits tels que des fichiers distribués ou un terminal de ligne de commande. Cette API est prise en charge par les langages de programmation Java et Scala.

Voici un programme Wordcount de l'API Dataset -

public class WordCountProg {
   public static void main(String[] args) throws Exception {
      final ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment();

      DataSet<String> text = env.fromElements(
      "Hello",
      "My Dataset API Flink Program");

      DataSet<Tuple2<String, Integer>> wordCounts = text
      .flatMap(new LineSplitter())
      .groupBy(0)
      .sum(1);

      wordCounts.print();
   }

   public static class LineSplitter implements FlatMapFunction<String, Tuple2<String, Integer>> {
      @Override
      public void flatMap(String line, Collector<Tuple2<String, Integer>> out) {
         for (String word : line.split(" ")) {
            out.collect(new Tuple2<String, Integer>(word, 1));
         }
      }
   }
}

API DataStream

Cette API est utilisée pour gérer les données en flux continu. Vous pouvez effectuer diverses opérations telles que le filtrage, le mappage, le fenêtrage, l'agrégation sur les données de flux. Il existe différentes sources sur ce flux de données telles que les files d'attente de messages, les fichiers, les flux de socket et les données de résultat peuvent être écrites sur différents récepteurs comme un terminal de ligne de commande. Les langages de programmation Java et Scala prennent en charge cette API.

Voici un programme Wordcount en continu de l'API DataStream, où vous avez un flux continu de décomptes de mots et les données sont regroupées dans la deuxième fenêtre.

import org.apache.flink.api.common.functions.FlatMapFunction;
import org.apache.flink.api.java.tuple.Tuple2;
import org.apache.flink.streaming.api.datastream.DataStream;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.windowing.time.Time;
import org.apache.flink.util.Collector;
public class WindowWordCountProg {
   public static void main(String[] args) throws Exception {
      StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
      DataStream<Tuple2<String, Integer>> dataStream = env
      .socketTextStream("localhost", 9999)
      .flatMap(new Splitter())
      .keyBy(0)
      .timeWindow(Time.seconds(5))
      .sum(1);
      dataStream.print();
      env.execute("Streaming WordCount Example");
   }
   public static class Splitter implements FlatMapFunction<String, Tuple2<String, Integer>> {
      @Override
      public void flatMap(String sentence, Collector<Tuple2<String, Integer>> out) throws Exception {
         for (String word: sentence.split(" ")) {
            out.collect(new Tuple2<String, Integer>(word, 1));
         }
      }
   }
}

L'API de table est une API relationnelle avec un langage d'expression similaire à SQL. Cette API peut effectuer à la fois le traitement par lots et par flux. Il peut être intégré avec les API Java et Scala Dataset et Datastream. Vous pouvez créer des tables à partir d'ensembles de données et de flux de données existants ou à partir de sources de données externes. Grâce à cette API relationnelle, vous pouvez effectuer des opérations telles que la jointure, l'agrégation, la sélection et le filtrage. Que l'entrée soit par lot ou par flux, la sémantique de la requête reste la même.

Voici un exemple de programme d'API Table -

// for batch programs use ExecutionEnvironment instead of StreamExecutionEnvironment
val env = StreamExecutionEnvironment.getExecutionEnvironment

// create a TableEnvironment
val tableEnv = TableEnvironment.getTableEnvironment(env)

// register a Table
tableEnv.registerTable("table1", ...) // or
tableEnv.registerTableSource("table2", ...) // or
tableEnv.registerExternalCatalog("extCat", ...)

// register an output Table
tableEnv.registerTableSink("outputTable", ...);
// create a Table from a Table API query
val tapiResult = tableEnv.scan("table1").select(...)
// Create a Table from a SQL query
val sqlResult = tableEnv.sqlQuery("SELECT ... FROM table2 ...")

// emit a Table API result Table to a TableSink, same for SQL result
tapiResult.insertInto("outputTable")

// execute
env.execute()

Dans ce chapitre, nous allons apprendre à créer une application Flink.

Ouvrez Eclipse IDE, cliquez sur Nouveau projet et sélectionnez Projet Java.

Donnez le nom du projet et cliquez sur Terminer.

Maintenant, cliquez sur Terminer comme indiqué dans la capture d'écran suivante.

Maintenant, faites un clic droit sur src et allez dans Nouvelle >> Classe.

Donnez un nom de classe et cliquez sur Terminer.

Copiez et collez le code ci-dessous dans l'éditeur.

import org.apache.flink.api.common.functions.FlatMapFunction;
import org.apache.flink.api.java.DataSet;
import org.apache.flink.api.java.ExecutionEnvironment;
import org.apache.flink.api.java.tuple.Tuple2;
import org.apache.flink.api.java.utils.ParameterTool;
import org.apache.flink.util.Collector;
public class WordCount {

   // *************************************************************************
   // PROGRAM
   // *************************************************************************
   public static void main(String[] args) throws Exception {
      final ParameterTool params = ParameterTool.fromArgs(args);
      // set up the execution environment
      final ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment();
      // make parameters available in the web interface
      env.getConfig().setGlobalJobParameters(params);
      // get input data
      DataSet<String> text = env.readTextFile(params.get("input"));
      DataSet<Tuple2<String, Integer>> counts =
      // split up the lines in pairs (2-tuples) containing: (word,1)
      text.flatMap(new Tokenizer())
      // group by the tuple field "0" and sum up tuple field "1"
      .groupBy(0)
      .sum(1);
      // emit result
      if (params.has("output")) {
         counts.writeAsCsv(params.get("output"), "\n", " ");
         // execute program
         env.execute("WordCount Example");
      } else {
         System.out.println("Printing result to stdout. Use --output to specify output path.");
         counts.print();
      }
   }
   
   // *************************************************************************
   // USER FUNCTIONS
   // *************************************************************************
   public static final class Tokenizer implements FlatMapFunction<String, Tuple2<String, Integer>> {
      public void flatMap(String value, Collector<Tuple2<String, Integer>> out) {
         // normalize and split the line
         String[] tokens = value.toLowerCase().split("\\W+");
         // emit the pairs
         for (String token : tokens) {
            if (token.length() > 0) {
               out.collect(new Tuple2<>(token, 1));
            }
         }
      }
   }
}

Vous obtiendrez de nombreuses erreurs dans l'éditeur, car les bibliothèques Flink doivent être ajoutées à ce projet.

Cliquez avec le bouton droit sur le projet >> Chemin de construction >> Configurer le chemin de construction.

Sélectionnez l'onglet Bibliothèques et cliquez sur Ajouter des JAR externes.

Allez dans le répertoire lib de Flink, sélectionnez les 4 bibliothèques et cliquez sur OK.

Allez dans l'onglet Order and Export, sélectionnez toutes les bibliothèques et cliquez sur OK.

Vous verrez que les erreurs ne sont plus là.

Maintenant, exportons cette application. Faites un clic droit sur le projet et cliquez sur Exporter.

Sélectionnez le fichier JAR et cliquez sur Suivant

Donnez un chemin de destination et cliquez sur Suivant

Cliquez sur Suivant>

Cliquez sur Parcourir, sélectionnez la classe principale (WordCount) et cliquez sur Terminer.

Note - Cliquez sur OK, au cas où vous auriez un avertissement.

Exécutez la commande ci-dessous. Il exécutera en outre l'application Flink que vous venez de créer.

./bin/flink run /home/ubuntu/wordcount.jar --input README.txt --output /home/ubuntu/output

Dans ce chapitre, nous allons apprendre à exécuter un programme Flink.

Exécutons l'exemple Flink wordcount sur un cluster Flink.

Accédez au répertoire personnel de Flink et exécutez la commande ci-dessous dans le terminal.

bin/flink run examples/batch/WordCount.jar -input README.txt -output /home/ubuntu/flink-1.7.1/output.txt

Accédez au tableau de bord Flink, vous pourrez voir un travail terminé avec ses détails.

Si vous cliquez sur Travaux terminés, vous obtiendrez un aperçu détaillé des travaux.

Pour vérifier la sortie du programme wordcount, exécutez la commande ci-dessous dans le terminal.

cat output.txt

Dans ce chapitre, nous allons découvrir les différentes bibliothèques d'Apache Flink.

Traitement des événements complexes (CEP)

FlinkCEP est une API dans Apache Flink, qui analyse les modèles d'événement sur les données de streaming continu. Ces événements sont quasiment en temps réel, avec un débit élevé et une faible latence. Cette API est principalement utilisée sur les données de capteur, qui arrivent en temps réel et sont très complexes à traiter.

Le CEP analyse le modèle du flux d'entrée et donne le résultat très bientôt. Il a la capacité de fournir des notifications et des alertes en temps réel au cas où le modèle d'événement serait complexe. FlinkCEP peut se connecter à différents types de sources d'entrée et analyser les modèles qu'elles contiennent.

Voici à quoi ressemble un exemple d'architecture avec CEP -

Les données des capteurs proviendront de différentes sources, Kafka agira comme un cadre de messagerie distribué, qui distribuera les flux à Apache Flink, et FlinkCEP analysera les modèles d'événements complexes.

Vous pouvez écrire des programmes dans Apache Flink pour le traitement d'événements complexes à l'aide de l'API Pattern. Il vous permet de décider des modèles d'événement à détecter à partir des données de flux continu. Vous trouverez ci-dessous quelques-uns des modèles CEP les plus couramment utilisés -

Commencer

Il est utilisé pour définir l'état de départ. Le programme suivant montre comment il est défini dans un programme Flink -

Pattern<Event, ?> next = start.next("next");

Où

Il est utilisé pour définir une condition de filtre dans l'état actuel.

patternState.where(new FilterFunction <Event>() {  
   @Override 
      public boolean filter(Event value) throws Exception { 
   } 
});

Prochain

Il est utilisé pour ajouter un nouvel état de modèle et l'événement correspondant nécessaire pour transmettre le modèle précédent.

Pattern<Event, ?> next = start.next("next");

Suivi par

Il est utilisé pour ajouter un nouvel état de modèle, mais ici, d'autres événements peuvent se produire entre deux événements correspondants.

Pattern<Event, ?> followedBy = start.followedBy("next");

Gelly

L'API Graph d'Apache Flink est Gelly. Gelly est utilisé pour effectuer une analyse graphique sur les applications Flink à l'aide d'un ensemble de méthodes et d'utilitaires. Vous pouvez analyser d'énormes graphiques à l'aide de l'API Apache Flink de manière distribuée avec Gelly. Il existe d'autres bibliothèques de graphes comme Apache Giraph dans le même but, mais comme Gelly est utilisé au-dessus d'Apache Flink, il utilise une seule API. Ceci est très utile du point de vue du développement et de l'exploitation.

Examinons un exemple en utilisant l'API Apache Flink - Gelly.

Tout d'abord, vous devez copier 2 fichiers jar Gelly du répertoire opt d'Apache Flink vers son répertoire lib. Ensuite, exécutez le pot flink-gelly-examples.

cp opt/flink-gelly* lib/ 
./bin/flink run examples/gelly/flink-gelly-examples_*.jar

Examinons maintenant l'exemple de PageRank.

PageRank calcule un score par sommet, qui est la somme des scores de PageRank transmis sur les bords entrants. Le score de chaque sommet est divisé uniformément entre les arêtes extérieures. Les sommets à score élevé sont liés à d'autres sommets à score élevé.

Le résultat contient l'ID de sommet et le score PageRank.

usage: flink run examples/flink-gelly-examples_<version>.jar --algorithm PageRank [algorithm options] --input <input> [input options] --output <output> [output options] 

./bin/flink run examples/gelly/flink-gelly-examples_*.jar --algorithm PageRank --input CycleGraph --vertex_count 2 --output Print

La bibliothèque d'apprentissage automatique d'Apache Flink s'appelle FlinkML. Étant donné que l'utilisation de l'apprentissage automatique a augmenté de manière exponentielle au cours des 5 dernières années, la communauté Flink a décidé d'ajouter cet APO d'apprentissage automatique à son écosystème. La liste des contributeurs et des algorithmes augmente dans FlinkML. Cette API ne fait pas encore partie de la distribution binaire.

Voici un exemple de régression linéaire utilisant FlinkML -

// LabeledVector is a feature vector with a label (class or real value)
val trainingData: DataSet[LabeledVector] = ...
val testingData: DataSet[Vector] = ...

// Alternatively, a Splitter is used to break up a DataSet into training and testing data.
val dataSet: DataSet[LabeledVector] = ...
val trainTestData: DataSet[TrainTestDataSet] = Splitter.trainTestSplit(dataSet)
val trainingData: DataSet[LabeledVector] = trainTestData.training
val testingData: DataSet[Vector] = trainTestData.testing.map(lv => lv.vector)
val mlr = MultipleLinearRegression()

.setStepsize(1.0)
.setIterations(100)
.setConvergenceThreshold(0.001)
mlr.fit(trainingData)

// The fitted model can now be used to make predictions
val predictions: DataSet[LabeledVector] = mlr.predict(testingData)

À l'intérieur flink-1.7.1/examples/batch/chemin, vous trouverez le fichier KMeans.jar. Examinons cet exemple d'exemple FlinkML.

Cet exemple de programme est exécuté en utilisant le point par défaut et le jeu de données centroïde.

./bin/flink run examples/batch/KMeans.jar --output Print

Dans ce chapitre, nous allons comprendre quelques cas de test dans Apache Flink.

Apache Flink - Bouygues Telecom

Bouygues Telecom est l'une des plus grandes organisations télécoms de France. Il compte plus de 11 millions d'abonnés mobiles et plus de 2,5 millions de clients fixes. Bouygues a entendu parler d'Apache Flink pour la première fois lors d'une réunion du groupe Hadoop à Paris. Depuis, ils utilisent Flink pour plusieurs cas d'utilisation. Ils traitent des milliards de messages par jour en temps réel via Apache Flink.

Voici ce que Bouygues a à dire à propos d'Apache Flink: «Nous nous sommes retrouvés avec Flink car le système prend en charge le vrai streaming - à la fois au niveau de l'API et au niveau de l'exécution, ce qui nous donne la programmabilité et la faible latence que nous recherchions. De plus, nous avons pu rendre notre système opérationnel avec Flink en une fraction du temps par rapport à d'autres solutions, ce qui a permis d'augmenter la disponibilité des ressources de développement pour étendre la logique métier du système. "

Chez Bouygues, l'expérience client est la priorité absolue. Ils analysent les données en temps réel afin de pouvoir donner ci-dessous des informations à leurs ingénieurs -

Expérience client en temps réel sur leur réseau
Que se passe-t-il dans le monde sur le réseau
Évaluations et opérations du réseau

Ils ont créé un système appelé LUX (Logged User Experience) qui traitait des données de journal massives provenant d'équipements réseau avec une référence de données interne pour donner des indicateurs de qualité d'expérience qui enregistreront leur expérience client et créeront une fonctionnalité alarmante pour détecter toute défaillance de la consommation de données dans les 60 ans. secondes.

Pour y parvenir, ils avaient besoin d'un cadre capable de prendre des données massives en temps réel, facile à configurer et fournissant un ensemble complet d'API pour le traitement des données diffusées. Apache Flink était parfaitement adapté à Bouygues Telecom.

Apache Flink - Alibaba

Alibaba est la plus grande entreprise de vente au détail de commerce électronique au monde avec 394 milliards de dollars de chiffre d'affaires en 2015. La recherche Alibaba est le point d'entrée de tous les clients, qui montre toute la recherche et recommande en conséquence.

Alibaba utilise Apache Flink dans son moteur de recherche pour afficher les résultats en temps réel avec la plus grande précision et pertinence pour chaque utilisateur.

Alibaba cherchait un cadre, qui était -

Très agile pour maintenir une base de code pour l'ensemble de leur processus d'infrastructure de recherche.
Fournit une faible latence pour les changements de disponibilité des produits sur le site Web.
Cohérent et rentable.

Apache Flink est qualifié pour toutes les exigences ci-dessus. Ils ont besoin d'un cadre, qui a un seul moteur de traitement et peut traiter à la fois des données par lots et par flux avec le même moteur et c'est ce que fait Apache Flink.

Ils utilisent également Blink, une version fourchue pour Flink pour répondre à certaines exigences uniques pour leur recherche. Ils utilisent également l'API Table d'Apache Flink avec quelques améliorations pour leur recherche.

Voici ce qu'Alibaba avait à dire à propos d'Apache Flink: " Avec le recul, ce fut sans aucun doute une année énorme pour Blink et Flink chez Alibaba. Personne ne pensait que nous ferions autant de progrès en un an, et nous sommes très reconnaissants à tous les gens qui nous ont aidés dans la communauté. Flink a fait ses preuves pour travailler à très grande échelle. Nous sommes plus que jamais engagés à continuer notre travail avec la communauté pour faire avancer Flink! "

Voici un tableau complet, qui montre la comparaison entre les trois frameworks Big Data les plus populaires: Apache Flink, Apache Spark et Apache Hadoop.

	Apache Hadoop	Apache Spark	Apache Flink
Year of Origin	2005	2009	2009
Place of Origin	MapReduce (Google) Hadoop (Yahoo)	Université de Californie, Berkeley	Université technique de Berlin
Data Processing Engine	Lot	Lot	Courant
Processing Speed	Plus lent que Spark et Flink	100x plus rapide que Hadoop	Plus rapide qu'une étincelle
Programming Languages	Java, C, C ++, Ruby, Groovy, Perl, Python	Java, Scala, python et R	Java et Scala
Programming Model	MapReduce	Ensembles de données distribués résilients (RDD)	Flux de données cycliques
Data Transfer	Lot	Lot	Pipeline et lot
Memory Management	Basé sur le disque	Géré par JVM	Géré actif
Latency	Faible	Moyen	Faible
Throughput	Moyen	Haute	Haute
Optimization	Manuel	Manuel	Automatique
API	Niveau faible	Haut niveau	Haut niveau
Streaming Support	N / A	Spark Streaming	Flink Streaming
SQL Support	Ruche, Impala	SparkSQL	API de table et SQL
Graph Support	N / A	GraphX	Gelly
Machine Learning Support	N / A	SparkML	FlinkML

Le tableau de comparaison que nous avons vu dans le chapitre précédent conclut à peu près les pointeurs. Apache Flink est le framework le plus adapté pour le traitement en temps réel et les cas d'utilisation. Son système à moteur unique est unique et peut traiter à la fois des données par lots et en continu avec différentes API telles que Dataset et DataStream.

Cela ne signifie pas que Hadoop et Spark sont hors du jeu, la sélection du framework Big Data le plus adapté dépend toujours et varie d'un cas d'utilisation à l'autre. Il peut y avoir plusieurs cas d'utilisation où une combinaison de Hadoop et Flink ou Spark et Flink peut convenir.

Néanmoins, Flink est actuellement le meilleur framework pour le traitement en temps réel. La croissance d'Apache Flink a été incroyable et le nombre de contributeurs à sa communauté augmente de jour en jour.

Joyeux clignotant!

Next page ↱