Apache Flink - Guida rapida

Il progresso dei dati negli ultimi 10 anni è stato enorme; questo ha dato origine al termine "Big Data". Non esiste una dimensione fissa dei dati, che puoi chiamare big data; tutti i dati che il tuo sistema tradizionale (RDBMS) non è in grado di gestire sono Big Data. Questi Big Data possono essere in formato strutturato, semi-strutturato o non strutturato. Inizialmente, c'erano tre dimensioni per i dati: volume, velocità, varietà. Le dimensioni ora sono andate oltre solo le tre vs. Ora abbiamo aggiunto altri V: Veridicità, Validità, Vulnerabilità, Valore, Variabilità, ecc.

I Big Data hanno portato all'emergere di molteplici strumenti e framework che aiutano nell'archiviazione e nell'elaborazione dei dati. Esistono alcuni framework di big data popolari come Hadoop, Spark, Hive, Pig, Storm e Zookeeper. Ha anche dato l'opportunità di creare prodotti Next Gen in più domini come sanità, finanza, vendita al dettaglio, e-commerce e altro ancora.

Che si tratti di una multinazionale o di una start-up, tutti stanno sfruttando i Big Data per archiviarli ed elaborarli e prendere decisioni più intelligenti.

In termini di Big Data, esistono due tipi di elaborazione:

Elaborazione in lotti
Elaborazione in tempo reale

L'elaborazione basata sui dati raccolti nel tempo è denominata Elaborazione batch. Ad esempio, un direttore di banca desidera elaborare i dati relativi a un mese precedente (raccolti nel tempo) per conoscere il numero di assegni annullati nell'ultimo mese.

L'elaborazione basata su dati immediati per risultati immediati è denominata elaborazione in tempo reale. Ad esempio, un direttore di banca che riceve un avviso di frode immediatamente dopo che si è verificata una transazione di frode (risultato immediato).

La tabella riportata di seguito elenca le differenze tra elaborazione in batch e in tempo reale -

Elaborazione in lotti	Elaborazione in tempo reale
File statici	Flussi di eventi
Elaborato periodicamente in minuti, ore, giorni ecc.	Elaborato immediatamente nanosecondi
Dati passati su archiviazione su disco	Nella memoria di archiviazione
Esempio: generazione di fatture	Esempio: avviso di transazione bancomat

In questi giorni, l'elaborazione in tempo reale viene utilizzata molto in ogni organizzazione. Casi d'uso come il rilevamento di frodi, avvisi in tempo reale nel settore sanitario e avvisi di attacchi di rete richiedono l'elaborazione in tempo reale di dati istantanei; un ritardo anche di pochi millisecondi può avere un impatto enorme.

Uno strumento ideale per tali casi d'uso in tempo reale sarebbe quello che può inserire dati come flusso e non come batch. Apache Flink è quello strumento di elaborazione in tempo reale.

Apache Flink è un framework di elaborazione in tempo reale in grado di elaborare dati in streaming. È un framework di elaborazione del flusso open source per applicazioni in tempo reale ad alte prestazioni, scalabili e accurate. Ha un vero modello di streaming e non accetta i dati di input come batch o micro-batch.

Apache Flink è stato fondato dalla società Data Artisans ed è ora sviluppato sotto licenza Apache dalla comunità di Apache Flink. Questa comunità ha oltre 479 collaboratori e più di 15500 commit finora.

Ecosistema su Apache Flink

Il diagramma riportato di seguito mostra i diversi livelli dell'ecosistema Apache Flink:

Conservazione

Apache Flink ha più opzioni da cui può leggere / scrivere dati. Di seguito è riportato un elenco di archiviazione di base:

HDFS (file system distribuito Hadoop)
File system locale
S3
RDBMS (MySQL, Oracle, MS SQL ecc.)
MongoDB
HBase
Apache Kafka
Apache Flume

Distribuisci

Puoi distribuire Apache Fink in modalità locale, modalità cluster o su cloud. La modalità cluster può essere standalone, YARN, MESOS.

Su cloud, Flink può essere distribuito su AWS o GCP.

Kernel

Questo è il livello runtime, che fornisce elaborazione distribuita, tolleranza agli errori, affidabilità, capacità di elaborazione iterativa nativa e altro ancora.

API e librerie

Questo è il livello superiore e il livello più importante di Apache Flink. Ha l'API Dataset, che si occupa dell'elaborazione in batch, e l'API Datastream, che si occupa dell'elaborazione del flusso. Esistono altre librerie come Flink ML (per l'apprendimento automatico), Gelly (per l'elaborazione di grafici), Tabelle per SQL. Questo livello fornisce diverse funzionalità ad Apache Flink.

Apache Flink funziona sull'architettura Kappa. L'architettura Kappa ha un unico processore: stream, che tratta tutti gli input come stream e il motore di streaming elabora i dati in tempo reale. I dati batch nell'architettura kappa sono un caso speciale di streaming.

Il diagramma seguente mostra il file Apache Flink Architecture.

L'idea chiave nell'architettura Kappa è quella di gestire i dati sia batch che in tempo reale attraverso un unico motore di elaborazione del flusso.

La maggior parte dei framework per big data funziona su architettura Lambda, che ha processori separati per batch e dati in streaming. Nell'architettura Lambda, hai codebase separati per le viste batch e stream. Per interrogare e ottenere il risultato, le basi di codice devono essere unite. Non mantenere basi di codice / viste separate e unirle è un problema, ma l'architettura Kappa risolve questo problema poiché ha una sola vista: in tempo reale, quindi non è richiesta la fusione della base di codice.

Ciò non significa che l'architettura Kappa sostituisca l'architettura Lambda, dipende completamente dal caso d'uso e dall'applicazione che decide quale architettura sarebbe preferibile.

Il diagramma seguente mostra l'architettura di esecuzione del lavoro di Apache Flink.

Programma

È un pezzo di codice, che puoi eseguire su Flink Cluster.

Cliente

È responsabile di prendere il codice (programma) e costruire il grafico del flusso di dati del lavoro, quindi passarlo a JobManager. Recupera anche i risultati del lavoro.

JobManager

Dopo aver ricevuto il grafico del flusso di dati del lavoro dal client, è responsabile della creazione del grafico di esecuzione. Assegna il lavoro ai Task Manager nel cluster e supervisiona l'esecuzione del lavoro.

TaskManager

È responsabile dell'esecuzione di tutte le attività assegnate da JobManager. Tutti i TaskManager eseguono le attività nei rispettivi slot separati nel parallelismo specificato. È responsabile dell'invio dello stato delle attività a JobManager.

Caratteristiche di Apache Flink

Le caratteristiche di Apache Flink sono le seguenti:

Ha un processore di streaming, che può eseguire sia programmi in batch che in streaming.
Può elaborare i dati a una velocità fulminea.
API disponibili in Java, Scala e Python.
Fornisce API per tutte le operazioni comuni, che è molto facile da usare per i programmatori.
Elabora i dati a bassa latenza (nanosecondi) e velocità effettiva elevata.
È tollerante agli errori. Se un nodo, un'applicazione o un hardware si guasta, non influisce sul cluster.
Può integrarsi facilmente con Apache Hadoop, Apache MapReduce, Apache Spark, HBase e altri strumenti per big data.
La gestione in memoria può essere personalizzata per una migliore elaborazione.
È altamente scalabile e può scalare fino a migliaia di nodi in un cluster.
Il windowing è molto flessibile in Apache Flink.
Fornisce librerie di elaborazione di grafici, apprendimento automatico e elaborazione di eventi complessi.

Di seguito sono riportati i requisiti di sistema per scaricare e lavorare su Apache Flink:

Sistema operativo consigliato

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

Requisiti di memoria

Memoria: minimo 4 GB, consigliato 8 GB
Spazio di archiviazione: 30 GB

Note - Java 8 deve essere disponibile con le variabili d'ambiente già impostate.

Prima di iniziare con la configurazione / installazione di Apache Flink, controlliamo se Java 8 è installato nel nostro sistema.

Java - versione

Procederemo ora scaricando Apache Flink.

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

Ora decomprimere il file tar.

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

Vai alla home directory di Flink.

cd flink-1.7.1/

Avvia Flink Cluster.

./bin/start-cluster.sh

Apri il browser Mozilla e vai all'URL seguente, si aprirà Flink Web Dashboard.

http://localhost:8081

Ecco come appare l'interfaccia utente di Apache Flink Dashboard.

Ora il cluster Flink è attivo e funzionante.

Flink ha un ricco set di API che utilizzano le quali gli sviluppatori possono eseguire trasformazioni su dati batch e in tempo reale. Una varietà di trasformazioni include mappatura, filtraggio, ordinamento, unione, raggruppamento e aggregazione. Queste trasformazioni di Apache Flink vengono eseguite sui dati distribuiti. Parliamo delle diverse API offerte da Apache Flink.

API del set di dati

L'API del set di dati in Apache Flink viene utilizzata per eseguire operazioni batch sui dati per un periodo. Questa API può essere utilizzata in Java, Scala e Python. Può applicare diversi tipi di trasformazioni ai set di dati come filtraggio, mappatura, aggregazione, unione e raggruppamento.

I set di dati vengono creati da fonti come file locali o leggendo un file da una particolare fonte ei dati dei risultati possono essere scritti su diversi sink come file distribuiti o terminale a riga di comando. Questa API è supportata dai linguaggi di programmazione Java e Scala.

Ecco un programma di conteggio parole dell'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

Questa API viene utilizzata per la gestione dei dati in flusso continuo. È possibile eseguire varie operazioni come il filtraggio, la mappatura, la creazione di finestre e l'aggregazione sui dati del flusso. Ci sono varie fonti su questo flusso di dati come code di messaggi, file, flussi di socket ei dati dei risultati possono essere scritti su diversi sink come il terminale della riga di comando. Entrambi i linguaggi di programmazione Java e Scala supportano questa API.

Ecco un programma di conteggio parole in streaming dell'API DataStream, in cui hai un flusso continuo di conteggi di parole ei dati sono raggruppati nella seconda finestra.

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 della tabella è un'API relazionale con linguaggio di espressione simile a SQL. Questa API può eseguire sia l'elaborazione in batch che in streaming. Può essere integrato con Java e Scala Dataset e API Datastream. È possibile creare tabelle da dataset e datastream esistenti o da origini dati esterne. Attraverso questa API relazionale, puoi eseguire operazioni come unire, aggregare, selezionare e filtrare. Indipendentemente dal fatto che l'input sia batch o flusso, la semantica della query rimane la stessa.

Ecco un esempio di programma API per tabelle:

// 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()

In questo capitolo impareremo come creare un'applicazione Flink.

Apri Eclipse IDE, fai clic su Nuovo progetto e seleziona Progetto Java.

Assegna un nome al progetto e fai clic su Fine.

Ora, fai clic su Fine come mostrato nello screenshot seguente.

Ora fai clic con il pulsante destro del mouse su src e vai a Nuovo >> Classe.

Assegna un nome alla classe e fai clic su Fine.

Copia e incolla il codice seguente nell'Editor.

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));
            }
         }
      }
   }
}

Otterrai molti errori nell'editor, perché le librerie Flink devono essere aggiunte a questo progetto.

Fare clic con il tasto destro sul progetto >> Build Path >> Configure Build Path.

Seleziona la scheda Librerie e fai clic su Aggiungi JAR esterni.

Vai alla directory lib di Flink, seleziona tutte le 4 librerie e fai clic su OK.

Vai alla scheda Ordina ed esporta, seleziona tutte le librerie e fai clic su OK.

Vedrai che gli errori non ci sono più.

Ora, esportiamo questa applicazione. Fare clic con il tasto destro sul progetto e fare clic su Esporta.

Seleziona il file JAR e fai clic su Avanti

Fornire un percorso di destinazione e fare clic su Avanti

Fare clic su Avanti>

Fare clic su Sfoglia, selezionare la classe principale (WordCount) e fare clic su Fine.

Note - Fare clic su OK, nel caso in cui venga visualizzato un avviso.

Esegui il comando seguente. Inoltre eseguirà l'applicazione Flink appena creata.

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

In questo capitolo impareremo come eseguire un programma Flink.

Eseguiamo l'esempio di conteggio parole Flink su un cluster Flink.

Vai alla home directory di Flink ed esegui il comando seguente nel terminale.

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

Vai alla dashboard di Flink, sarai in grado di vedere un lavoro completato con i suoi dettagli.

Se fai clic su Lavori completati, otterrai una panoramica dettagliata dei lavori.

Per controllare l'output del programma conteggio parole, eseguire il comando seguente nel terminale.

cat output.txt

In questo capitolo impareremo le diverse librerie di Apache Flink.

Elaborazione di eventi complessi (CEP)

FlinkCEP è un'API in Apache Flink, che analizza i modelli di eventi sui dati in streaming continuo. Questi eventi sono quasi in tempo reale, che hanno un throughput elevato e una bassa latenza. Questa API viene utilizzata principalmente sui dati del sensore, che arrivano in tempo reale e sono molto complessi da elaborare.

CEP analizza il modello del flusso di input e fornisce il risultato molto presto. Ha la capacità di fornire notifiche e avvisi in tempo reale nel caso in cui il pattern degli eventi sia complesso. FlinkCEP può connettersi a diversi tipi di sorgenti di input e analizzare i modelli in esse contenuti.

Ecco come appare un'architettura di esempio con CEP:

I dati dei sensori arriveranno da diverse fonti, Kafka fungerà da framework di messaggistica distribuita, che distribuirà i flussi ad Apache Flink e FlinkCEP analizzerà i complessi modelli di eventi.

È possibile scrivere programmi in Apache Flink per l'elaborazione di eventi complessi utilizzando Pattern API. Consente di decidere i modelli di eventi da rilevare dai dati del flusso continuo. Di seguito sono riportati alcuni dei modelli CEP più comunemente utilizzati:

Inizio

Viene utilizzato per definire lo stato iniziale. Il seguente programma mostra come viene definito in un programma Flink:

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

Dove

Viene utilizzato per definire una condizione di filtro nello stato corrente.

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

Il prossimo

Viene utilizzato per aggiungere un nuovo stato del pattern e l'evento corrispondente necessario per passare il pattern precedente.

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

Seguito da

Viene utilizzato per aggiungere un nuovo stato del pattern, ma qui possono verificarsi altri eventi in bianco e nero con due eventi corrispondenti.

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

Gelly

L'API Graph di Apache Flink è Gelly. Gelly viene utilizzato per eseguire analisi di grafici su applicazioni Flink utilizzando una serie di metodi e utilità. Puoi analizzare enormi grafici utilizzando Apache Flink API in modo distribuito con Gelly. Esistono anche altre librerie grafiche come Apache Giraph per lo stesso scopo, ma poiché Gelly viene utilizzato sopra Apache Flink, utilizza una singola API. Questo è molto utile dal punto di vista dello sviluppo e del funzionamento.

Facciamo un esempio utilizzando Apache Flink API - Gelly.

In primo luogo, è necessario copiare 2 file jar Gelly dalla directory opt di Apache Flink alla sua directory lib. Quindi esegui flink-gelly-examples jar.

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

Eseguiamo ora l'esempio del PageRank.

Il PageRank calcola un punteggio per vertice, che è la somma dei punteggi di PageRank trasmessi sugli in-edge. Il punteggio di ogni vertice è diviso equamente tra i bordi esterni. I vertici con punteggio elevato sono collegati da altri vertici con punteggio elevato.

Il risultato contiene l'ID vertice e il punteggio 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 libreria di Machine Learning di Apache Flink si chiama FlinkML. Poiché l'utilizzo dell'apprendimento automatico è aumentato in modo esponenziale negli ultimi 5 anni, la comunità di Flink ha deciso di aggiungere questo APO di apprendimento automatico anche nel suo ecosistema. L'elenco dei contributori e degli algoritmi sta aumentando in FlinkML. Questa API non fa ancora parte della distribuzione binaria.

Ecco un esempio di regressione lineare utilizzando 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)

Dentro flink-1.7.1/examples/batch/percorso, troverai il file KMeans.jar. Eseguiamo questo esempio FlinkML di esempio.

Questo programma di esempio viene eseguito utilizzando il punto predefinito e il set di dati del centroide.

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

In questo capitolo, comprenderemo alcuni casi di test in Apache Flink.

Apache Flink - Bouygues Telecom

Bouygues Telecom è una delle più grandi organizzazioni di telecomunicazioni in Francia. Ha oltre 11 milioni di abbonati mobili e oltre 2,5 milioni di clienti fissi. Bouygues ha sentito parlare di Apache Flink per la prima volta in una riunione del gruppo Hadoop tenutasi a Parigi. Da allora hanno utilizzato Flink per molteplici casi d'uso. Hanno elaborato miliardi di messaggi in un giorno in tempo reale tramite Apache Flink.

Questo è ciò che Bouygues ha da dire su Apache Flink: "Abbiamo scelto Flink perché il sistema supporta il vero streaming, sia a livello di API che di runtime, dandoci la programmabilità e la bassa latenza che stavamo cercando. Inoltre, siamo stati in grado di mettere in funzione il nostro sistema con Flink in una frazione del tempo rispetto ad altre soluzioni, il che ha portato a maggiori risorse per sviluppatori disponibili per espandere la logica di business nel sistema ".

In Bouygues, l'esperienza del cliente è la massima priorità. Analizzano i dati in tempo reale in modo che possano fornire le seguenti informazioni ai loro ingegneri:

Esperienza del cliente in tempo reale sulla propria rete
Cosa sta accadendo a livello globale sulla rete
Valutazioni e operazioni di rete

Hanno creato un sistema chiamato LUX (Logged User Experience) che ha elaborato enormi dati di registro da apparecchiature di rete con riferimento interno ai dati per fornire indicatori di qualità dell'esperienza che registreranno la loro esperienza del cliente e costruiranno una funzionalità allarmante per rilevare qualsiasi errore nel consumo di dati entro 60 secondi.

Per raggiungere questo obiettivo, avevano bisogno di un framework in grado di acquisire dati di grandi dimensioni in tempo reale, che fosse facile da configurare e fornisse un ricco set di API per l'elaborazione dei dati in streaming. Apache Flink era perfetto per Bouygues Telecom.

Apache Flink - Alibaba

Alibaba è la più grande azienda di vendita al dettaglio di e-commerce al mondo con 394 miliardi di dollari di entrate nel 2015. La ricerca di Alibaba è il punto di ingresso per tutti i clienti, che mostra tutte le ricerche e consiglia di conseguenza.

Alibaba utilizza Apache Flink nel suo motore di ricerca per mostrare i risultati in tempo reale con la massima precisione e pertinenza per ogni utente.

Alibaba stava cercando un framework, che era:

Molto agile nel mantenere una base di codice per l'intero processo dell'infrastruttura di ricerca.
Fornisce una bassa latenza per le modifiche alla disponibilità dei prodotti sul sito web.
Coerente e conveniente.

Apache Flink si è qualificato per tutti i requisiti di cui sopra. Hanno bisogno di un framework, che ha un singolo motore di elaborazione e può elaborare sia batch che dati di flusso con lo stesso motore e questo è ciò che fa Apache Flink.

Usano anche Blink, una versione biforcuta per Flink per soddisfare alcuni requisiti unici per la loro ricerca. Stanno anche usando l'API Table di Apache Flink con pochi miglioramenti per la loro ricerca.

Questo è ciò che Alibaba aveva da dire su Apache Flink: " Guardando indietro, è stato senza dubbio un anno enorme per Blink e Flink ad Alibaba. Nessuno pensava che avremmo fatto così tanti progressi in un anno, e siamo molto grati a tutti le persone che ci hanno aiutato nella comunità. È dimostrato che Flink lavora su larga scala. Siamo più impegnati che mai a continuare il nostro lavoro con la comunità per far avanzare Flink! "

Ecco una tabella completa, che mostra il confronto tra i tre framework di big data più popolari: Apache Flink, Apache Spark e Apache Hadoop.

	Apache Hadoop	Apache Spark	Apache Flink
Year of Origin	2005	2009	2009
Place of Origin	MapReduce (Google) Hadoop (Yahoo)	Università della California, Berkeley	Università Tecnica di Berlino
Data Processing Engine	Lotto	Lotto	Stream
Processing Speed	Più lento di Spark e Flink	100 volte più veloce di Hadoop	Più veloce della scintilla
Programming Languages	Java, C, C ++, Ruby, Groovy, Perl, Python	Java, Scala, Python e R	Java e Scala
Programming Model	Riduci mappa	Set di dati distribuiti resilienti (RDD)	Flussi di dati ciclici
Data Transfer	Lotto	Lotto	Pipelined e batch
Memory Management	Basato su disco	Gestito da JVM	Gestito attivo
Latency	Basso	medio	Basso
Throughput	medio	Alto	Alto
Optimization	Manuale	Manuale	Automatico
API	Basso livello	Alto livello	Alto livello
Streaming Support	N / A	Spark Streaming	Flink Streaming
SQL Support	Alveare, Impala	SparkSQL	Tabella API e SQL
Graph Support	N / A	GraphX	Gelly
Machine Learning Support	N / A	SparkML	FlinkML

La tabella di confronto che abbiamo visto nel capitolo precedente conclude praticamente i puntatori. Apache Flink è il framework più adatto per l'elaborazione in tempo reale e i casi d'uso. Il suo sistema a motore singolo è unico in grado di elaborare sia dati in batch che in streaming con diverse API come Dataset e DataStream.

Ciò non significa che Hadoop e Spark siano fuori dal gioco, la selezione del framework di big data più adatto dipende sempre e varia da caso d'uso a caso d'uso. Ci possono essere diversi casi d'uso in cui una combinazione di Hadoop e Flink o Spark e Flink potrebbe essere adatta.

Tuttavia, Flink è attualmente il miglior framework per l'elaborazione in tempo reale. La crescita di Apache Flink è stata sorprendente e il numero di collaboratori della sua comunità cresce di giorno in giorno.

Happy Flinking!