Apache Flink - Szybki przewodnik

Postęp danych w ciągu ostatnich 10 lat był ogromny; dało to początek określeniu „Big Data”. Nie ma stałego rozmiaru danych, które można nazwać dużymi danymi; wszelkie dane, których Twój tradycyjny system (RDBMS) nie jest w stanie obsłużyć, to Big Data. Te Big Data mogą mieć format ustrukturyzowany, częściowo ustrukturyzowany lub nieustrukturyzowany. Początkowo istniały trzy wymiary danych - objętość, prędkość, różnorodność. Wymiary przekroczyły teraz tylko trzy Vs. Dodaliśmy teraz inne V - Veracity, Validity, Vulnerability, Value, Variability itd.

Big Data doprowadziło do pojawienia się wielu narzędzi i struktur, które pomagają w przechowywaniu i przetwarzaniu danych. Istnieje kilka popularnych frameworków do dużych zbiorów danych, takich jak Hadoop, Spark, Hive, Pig, Storm i Zookeeper. Dało to również możliwość tworzenia produktów nowej generacji w wielu domenach, takich jak opieka zdrowotna, finanse, handel detaliczny, handel elektroniczny i nie tylko.

Niezależnie od tego, czy jest to MNC, czy start-up, każdy wykorzystuje Big Data do ich przechowywania i przetwarzania oraz podejmowania mądrzejszych decyzji.

Jeśli chodzi o Big Data, istnieją dwa rodzaje przetwarzania -

Przetwarzanie wsadowe
Przetwarzanie w czasie rzeczywistym

Przetwarzanie na podstawie danych gromadzonych w czasie nazywa się przetwarzaniem wsadowym. Na przykład menedżer banku chce przetworzyć dane z ostatniego miesiąca (zebrane w czasie), aby poznać liczbę czeków, które zostały anulowane w ciągu ostatniego miesiąca.

Przetwarzanie oparte na natychmiastowych danych w celu uzyskania natychmiastowych wyników nazywa się przetwarzaniem w czasie rzeczywistym. Na przykład menedżer banku otrzymujący alert o oszustwie natychmiast po wystąpieniu oszustwa (natychmiastowy wynik).

Poniższa tabela przedstawia różnice między przetwarzaniem wsadowym i przetwarzaniem w czasie rzeczywistym -

Przetwarzanie wsadowe	Przetwarzanie w czasie rzeczywistym
Pliki statyczne	Strumienie wydarzeń
Przetwarzane okresowo w minutach, godzinach, dniach itp.	Przetwarzane natychmiast nanosekund
Wcześniejsze dane na dysku	W pamięci
Przykład - generowanie rachunku	Przykład - alert transakcji w bankomacie

Obecnie każda organizacja często wykorzystuje przetwarzanie w czasie rzeczywistym. Przypadki użycia, takie jak wykrywanie oszustw, alerty w czasie rzeczywistym w służbie zdrowia i ostrzeżenia o atakach sieciowych, wymagają natychmiastowego przetwarzania danych w czasie rzeczywistym; opóźnienie nawet kilku milisekund może mieć ogromny wpływ.

Idealnym narzędziem do takich przypadków użycia w czasie rzeczywistym byłoby to, które może wprowadzać dane jako strumień, a nie wsad. Apache Flink to narzędzie do przetwarzania w czasie rzeczywistym.

Apache Flink to platforma przetwarzania w czasie rzeczywistym, która może przetwarzać dane strumieniowe. Jest to platforma przetwarzania strumienia typu open source dla wysokowydajnych, skalowalnych i dokładnych aplikacji czasu rzeczywistego. Ma prawdziwy model przesyłania strumieniowego i nie pobiera danych wejściowych jako partii lub mikro-partii.

Apache Flink został założony przez firmę Data Artisans i jest obecnie rozwijany na licencji Apache przez społeczność Apache Flink. Ta społeczność ma do tej pory ponad 479 współtwórców i ponad 15500 zatwierdzeń.

Ekosystem na Apache Flink

Poniższy diagram przedstawia różne warstwy ekosystemu Apache Flink -

Przechowywanie

Apache Flink ma wiele opcji, z których może odczytywać / zapisywać dane. Poniżej znajduje się podstawowa lista przechowywania -

HDFS (rozproszony system plików Hadoop)
Lokalny system plików
S3
RDBMS (MySQL, Oracle, MS SQL itp.)
MongoDB
HBase
Apache Kafka
Apache Flume

Rozmieścić

Możesz wdrożyć Apache Fink w trybie lokalnym, trybie klastra lub w chmurze. Tryb klastra może być samodzielny, YARN, MESOS.

W chmurze Flink można wdrożyć na AWS lub GCP.

Jądro

Jest to warstwa środowiska wykonawczego, która zapewnia przetwarzanie rozproszone, odporność na błędy, niezawodność, natywne możliwości iteracyjnego przetwarzania i nie tylko.

API i biblioteki

To jest górna warstwa i najważniejsza warstwa Apache Flink. Posiada Dataset API, które zajmuje się przetwarzaniem wsadowym oraz Datastream API, które zajmuje się przetwarzaniem strumieniowym. Istnieją inne biblioteki, takie jak Flink ML (do uczenia maszynowego), Gelly (do przetwarzania wykresów), Tables for SQL. Ta warstwa zapewnia różnorodne możliwości Apache Flink.

Apache Flink pracuje nad architekturą Kappa. Architektura Kappa ma pojedynczy procesor - strumień, który traktuje wszystkie dane wejściowe jako strumień, a silnik przesyłania strumieniowego przetwarza dane w czasie rzeczywistym. Dane wsadowe w architekturze kappa to szczególny przypadek przesyłania strumieniowego.

Poniższy diagram przedstawia Apache Flink Architecture.

Kluczową ideą architektury Kappa jest obsługa zarówno danych wsadowych, jak i danych w czasie rzeczywistym za pomocą silnika przetwarzania pojedynczego strumienia.

Większość frameworków do dużych zbiorów danych działa na architekturze Lambda, która ma oddzielne procesory dla danych wsadowych i strumieniowych. W architekturze Lambda masz oddzielne bazy kodów dla widoków wsadowych i strumieniowych. Aby wykonać zapytanie i uzyskać wynik, należy scalić bazy kodów. Nie utrzymywanie oddzielnych baz kodów / widoków i łączenie ich jest uciążliwe, ale architektura Kappa rozwiązuje ten problem, ponieważ ma tylko jeden widok - w czasie rzeczywistym, dlatego scalanie bazy kodu nie jest wymagane.

Nie oznacza to, że architektura Kappa zastępuje architekturę Lambda, całkowicie zależy od przypadku użycia i aplikacji, która decyduje, która architektura byłaby lepsza.

Poniższy diagram przedstawia architekturę wykonywania zadań Apache Flink.

Program

Jest to fragment kodu, który uruchamiasz w klastrze Flink.

Klient

Odpowiada za pobranie kodu (programu) i zbudowanie wykresu przepływu danych pracy, a następnie przekazanie go do JobManager. Pobiera również wyniki zadania.

JobManager

Po otrzymaniu Job Dataflow Graph od Klienta odpowiada za stworzenie wykresu wykonania. Przydziela zadanie do TaskManagerów w klastrze i nadzoruje wykonanie zadania.

Menadżer zadań

Odpowiada za wykonanie wszystkich zadań, które zostały przydzielone przez JobManager. Wszyscy menedżerowie zadań uruchamiają zadania w swoich oddzielnych gniazdach z określoną równoległością. Jest odpowiedzialny za wysyłanie statusu zadań do JobManager.

Funkcje Apache Flink

Funkcje Apache Flink są następujące -

Posiada procesor przesyłania strumieniowego, który może obsługiwać zarówno programy wsadowe, jak i strumieniowe.
Potrafi przetwarzać dane z prędkością błyskawicy.
Interfejsy API dostępne w językach Java, Scala i Python.
Zapewnia interfejsy API dla wszystkich typowych operacji, co jest bardzo łatwe w użyciu dla programistów.
Przetwarza dane z małym opóźnieniem (nanosekund) i dużą przepustowością.
Jest odporny na uszkodzenia. Jeśli węzeł, aplikacja lub sprzęt ulegną awarii, nie ma to wpływu na klaster.
Można łatwo zintegrować z Apache Hadoop, Apache MapReduce, Apache Spark, HBase i innymi narzędziami do dużych zbiorów danych.
Zarządzanie w pamięci można dostosować dla lepszych obliczeń.
Jest wysoce skalowalny i może skalować się do tysięcy węzłów w klastrze.
Okienkowanie jest bardzo elastyczne w Apache Flink.
Zapewnia przetwarzanie wykresów, uczenie maszynowe i biblioteki przetwarzania złożonych zdarzeń.

Poniżej przedstawiono wymagania systemowe do pobrania i pracy z Apache Flink -

Zalecany system operacyjny

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

Wymagania dotyczące pamięci

Pamięć - co najmniej 4 GB, zalecane 8 GB
Przestrzeń dyskowa - 30 GB

Note - Java 8 musi być dostępna z już ustawionymi zmiennymi środowiskowymi.

Zanim zaczniemy konfigurację / instalację Apache Flink, sprawdźmy, czy w naszym systemie jest zainstalowana Java 8.

Java - wersja

Będziemy teraz kontynuować pobieranie Apache Flink.

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

Teraz rozpakuj plik tar.

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

Przejdź do katalogu domowego Flink.

cd flink-1.7.1/

Uruchom Flink Cluster.

./bin/start-cluster.sh

Otwórz przeglądarkę Mozilla i przejdź do poniższego adresu URL, otworzy się pulpit nawigacyjny Flink Web.

http://localhost:8081

Tak wygląda interfejs użytkownika Apache Flink Dashboard.

Teraz klaster Flink jest gotowy i działa.

Flink ma bogaty zestaw interfejsów API, za pomocą których programiści mogą wykonywać transformacje zarówno na danych wsadowych, jak i danych w czasie rzeczywistym. Różnorodne transformacje obejmują mapowanie, filtrowanie, sortowanie, łączenie, grupowanie i agregowanie. Te transformacje przez Apache Flink są wykonywane na rozproszonych danych. Omówmy różne interfejsy API oferowane przez Apache Flink.

Dataset API

Dataset API w Apache Flink służy do wykonywania operacji wsadowych na danych w okresie. Tego interfejsu API można używać w językach Java, Scala i Python. Może stosować różne rodzaje przekształceń na zbiorach danych, takie jak filtrowanie, mapowanie, agregowanie, łączenie i grupowanie.

Zestawy danych są tworzone ze źródeł, takich jak pliki lokalne lub przez odczytanie pliku z określonego źródła, a dane wynikowe mogą być zapisywane w różnych ujściach, takich jak pliki rozproszone lub terminal wiersza poleceń. Ten interfejs API jest obsługiwany przez języki programowania Java i Scala.

Oto program Wordcount interfejsu API zestawu danych -

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

DataStream API

Ten interfejs API służy do obsługi danych w ciągłym strumieniu. Na strumieniu danych można wykonywać różne operacje, takie jak filtrowanie, mapowanie, okienkowanie, agregowanie. Istnieją różne źródła tego strumienia danych, takie jak kolejki komunikatów, pliki, strumienie gniazd, a dane wynikowe mogą być zapisywane w różnych ujściach, takich jak terminal wiersza poleceń. Ten interfejs API obsługują języki programowania Java i Scala.

Oto program strumieniowy Wordcount API DataStream, w którym masz ciągły strumień liczby słów, a dane są grupowane w drugim oknie.

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

Table API to relacyjny interfejs API z językiem wyrażeń podobnym do SQL. Ten interfejs API może wykonywać zarówno przetwarzanie wsadowe, jak i strumieniowe. Może być osadzony za pomocą interfejsów API Java i Scala Dataset oraz Datastream. Możesz tworzyć tabele na podstawie istniejących zestawów danych i strumieni danych lub z zewnętrznych źródeł danych. Za pomocą tego relacyjnego interfejsu API można wykonywać operacje, takie jak łączenie, agregowanie, wybieranie i filtrowanie. Niezależnie od tego, czy dane wejściowe są wsadowe, czy strumieniowe, semantyka zapytania pozostaje taka sama.

Oto przykładowy program Table API -

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

W tym rozdziale nauczymy się, jak stworzyć aplikację Flink.

Otwórz Eclipse IDE, kliknij New Project i Select Java Project.

Podaj nazwę projektu i kliknij Zakończ.

Teraz kliknij Zakończ, jak pokazano na poniższym zrzucie ekranu.

Teraz kliknij prawym przyciskiem myszy src i przejdź do New >> Class.

Podaj nazwę klasy i kliknij Zakończ.

Skopiuj i wklej poniższy kod w Edytorze.

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

Otrzymasz wiele błędów w edytorze, ponieważ biblioteki Flink muszą zostać dodane do tego projektu.

Kliknij prawym przyciskiem myszy projekt >> Ścieżka budowania >> Konfiguruj ścieżkę budowania.

Wybierz kartę Biblioteki i kliknij Dodaj zewnętrzne pliki JAR.

Przejdź do katalogu bibliotek Flink, wybierz wszystkie 4 biblioteki i kliknij OK.

Przejdź do zakładki Zamów i eksportuj, wybierz wszystkie biblioteki i kliknij OK.

Zobaczysz, że błędów już nie ma.

Teraz wyeksportujmy tę aplikację. Kliknij projekt prawym przyciskiem myszy i kliknij Eksportuj.

Wybierz plik JAR i kliknij Dalej

Podaj ścieżkę docelową i kliknij Dalej

Kliknij Dalej>

Kliknij Przeglądaj, wybierz główną klasę (WordCount) i kliknij Zakończ.

Note - Kliknij OK, jeśli pojawi się jakieś ostrzeżenie.

Uruchom poniższe polecenie. Spowoduje to dalsze uruchomienie właśnie utworzonej aplikacji Flink.

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

W tym rozdziale nauczymy się, jak uruchomić program Flink.

Uruchommy przykład Flink wordcount na klastrze Flink.

Przejdź do katalogu domowego Flinka i uruchom poniższe polecenie w terminalu.

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

Przejdź do pulpitu Flink, będziesz mógł zobaczyć ukończoną pracę wraz z jej szczegółami.

Jeśli klikniesz Zakończone prace, otrzymasz szczegółowy przegląd prac.

Aby sprawdzić wyjście programu wordcount, uruchom poniższe polecenie w terminalu.

cat output.txt

W tym rozdziale dowiemy się o różnych bibliotekach Apache Flink.

Przetwarzanie złożonych zdarzeń (CEP)

FlinkCEP to API w Apache Flink, które analizuje wzorce zdarzeń w ciągłym przesyłaniu strumieniowym danych. Te zdarzenia są zbliżone do czasu rzeczywistego i mają wysoką przepustowość i małe opóźnienia. Ten interfejs API jest używany głównie w przypadku danych czujnika, które są przesyłane w czasie rzeczywistym i są bardzo złożone w przetwarzaniu.

CEP analizuje wzorzec strumienia wejściowego i bardzo szybko podaje wynik. Ma możliwość dostarczania powiadomień i alertów w czasie rzeczywistym w przypadku, gdy wzorzec zdarzenia jest złożony. FlinkCEP może łączyć się z różnego rodzaju źródłami wejściowymi i analizować w nich wzorce.

Tak wygląda przykładowa architektura z CEP -

Dane z czujników będą pochodzić z różnych źródeł, Kafka będzie działać jako rozproszona platforma przesyłania wiadomości, która będzie dystrybuować strumienie do Apache Flink, a FlinkCEP przeanalizuje złożone wzorce zdarzeń.

Możesz pisać programy w Apache Flink do przetwarzania złożonych zdarzeń przy użyciu Pattern API. Pozwala zdecydować, jakie wzorce zdarzeń mają być wykrywane z danych ciągłego strumienia. Poniżej znajdują się niektóre z najczęściej używanych wzorców CEP -

Zaczynać

Służy do określenia stanu początkowego. Poniższy program pokazuje, jak jest zdefiniowany w programie Flink -

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

Gdzie

Służy do definiowania warunku filtru w bieżącym stanie.

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

Kolejny

Służy do dołączania nowego stanu wzorca i zdarzenia dopasowania potrzebnego do przekazania poprzedniego wzorca.

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

Śledzony przez

Służy do dołączania nowego stanu wzorca, ale tutaj mogą wystąpić inne zdarzenia b / w dwóch pasujących zdarzeń.

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

Gelly

Graph API Apache Flink to Gelly. Gelly służy do wykonywania analizy wykresów w aplikacjach Flink przy użyciu zestawu metod i narzędzi. Możesz analizować ogromne wykresy za pomocą Apache Flink API w sposób rozproszony za pomocą Gelly. Istnieją również inne biblioteki wykresów, takie jak Apache Giraph, które służą do tego samego celu, ale ponieważ Gelly jest używany nad Apache Flink, używa pojedynczego interfejsu API. Jest to bardzo pomocne z punktu widzenia rozwoju i eksploatacji.

Uruchommy przykład wykorzystujący API Apache Flink - Gelly.

Po pierwsze, musisz skopiować 2 pliki jar Gelly z katalogu opt Apache Flink do jego katalogu lib. Następnie uruchom słoik flink-gelly-examples.

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

Przeprowadźmy teraz przykład PageRank.

PageRank oblicza wynik na wierzchołek, który jest sumą wyników PageRank przesyłanych na krawędziach. Wynik każdego wierzchołka jest podzielony równo między zewnętrzne krawędzie. Wierzchołki o wysokim wyniku są połączone z innymi wierzchołkami o wysokim wyniku.

Wynik zawiera identyfikator wierzchołka i wynik 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

Biblioteka uczenia maszynowego Apache Flink nosi nazwę FlinkML. Ponieważ wykorzystanie uczenia maszynowego rosło wykładniczo w ciągu ostatnich 5 lat, społeczność Flink zdecydowała się dodać to uczenie maszynowe APO również do swojego ekosystemu. Lista współautorów i algorytmów rośnie w FlinkML. To API nie jest jeszcze częścią dystrybucji binarnej.

Oto przykład regresji liniowej przy użyciu 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)

Wewnątrz flink-1.7.1/examples/batch/ścieżka, znajdziesz plik KMeans.jar. Uruchommy ten przykładowy przykład FlinkML.

Ten przykładowy program jest uruchamiany przy użyciu punktu domyślnego i zestawu danych środka ciężkości.

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

W tym rozdziale zrozumiemy kilka przypadków testowych w Apache Flink.

Apache Flink - Bouygues Telecom

Bouygues Telecom jest jedną z największych organizacji telekomunikacyjnych we Francji. Ma ponad 11 milionów abonentów telefonii komórkowej i ponad 2,5 miliona klientów stacjonarnych. Bouygues po raz pierwszy usłyszał o Apache Flink na spotkaniu grupy Hadoop w Paryżu. Od tego czasu używają Flinka do wielu zastosowań. Przetwarzają miliardy wiadomości dziennie w czasie rzeczywistym za pośrednictwem Apache Flink.

Oto, co Bouygues ma do powiedzenia na temat Apache Flink: „ Skończyło się na Flink, ponieważ system obsługuje prawdziwe przesyłanie strumieniowe - zarówno na poziomie API, jak i na poziomie środowiska wykonawczego, zapewniając nam programowalność i małe opóźnienia, których szukaliśmy. Ponadto, byliśmy w stanie uruchomić i uruchomić nasz system za pomocą Flink w ułamku czasu w porównaniu z innymi rozwiązaniami, co zaowocowało większą dostępnością zasobów programistów w celu rozszerzenia logiki biznesowej w systemie ”.

W Bouygues doświadczenie klienta jest najwyższym priorytetem. Analizują dane w czasie rzeczywistym, dzięki czemu mogą przekazywać inżynierom poniższe informacje:

Doświadczenie klienta w czasie rzeczywistym w ich sieci
Co się dzieje w sieci na całym świecie
Oceny i operacje sieci

Stworzyli system o nazwie LUX (Logged User Experience), który przetwarzał ogromne dane dziennika ze sprzętu sieciowego z wewnętrznym odniesieniem do danych, aby zapewnić wskaźniki jakości, które będą rejestrować doświadczenia klientów i budować alarmującą funkcjonalność w celu wykrycia wszelkich awarii w zużyciu danych w ciągu 60 sekundy.

Aby to osiągnąć, potrzebowali platformy, która może pobierać ogromne ilości danych w czasie rzeczywistym, jest łatwa w konfiguracji i zapewnia bogaty zestaw interfejsów API do przetwarzania danych przesyłanych strumieniowo. Apache Flink idealnie pasował do Bouygues Telecom.

Apache Flink - Alibaba

Alibaba to największa na świecie firma zajmująca się handlem detalicznym w handlu elektronicznym z 394 miliardami dolarów przychodów w 2015 roku. Wyszukiwarka Alibaba to punkt wejścia dla wszystkich klientów, który pokazuje wszystkie wyszukiwania i odpowiednio rekomenduje.

Alibaba korzysta z Apache Flink w swojej wyszukiwarce, aby wyświetlać wyniki w czasie rzeczywistym z najwyższą dokładnością i trafnością dla każdego użytkownika.

Alibaba szukał frameworka, który byłby -

Bardzo sprawny w utrzymywaniu jednej bazy kodu dla całego procesu infrastruktury wyszukiwania.
Zapewnia małe opóźnienie zmian dostępności produktów w witrynie internetowej.
Konsekwentne i ekonomiczne.

Apache Flink spełnia wszystkie powyższe wymagania. Potrzebują struktury, która ma pojedynczy silnik przetwarzania i może przetwarzać zarówno dane wsadowe, jak i strumieniowe za pomocą tego samego silnika, i to właśnie robi Apache Flink.

Używają również Blink, rozwidlonej wersji Flinka, aby spełnić pewne unikalne wymagania dotyczące ich wyszukiwania. Korzystają również z interfejsu API tabel Apache Flink z kilkoma ulepszeniami wyszukiwania.

Oto, co Alibaba miał do powiedzenia na temat Apache Flink: „ Patrząc wstecz, bez wątpienia był to ogromny rok dla Blink and Flink w Alibaba. Nikt nie przypuszczał, że zrobimy tak duży postęp w ciągu roku i jesteśmy wszystkim bardzo wdzięczni ludzi, którzy pomogli nam w społeczności. Udowodniono, że Flink działa na bardzo dużą skalę. Jesteśmy bardziej niż kiedykolwiek zaangażowani w kontynuowanie naszej pracy ze społecznością, aby rozwijać Flink! ”

Oto obszerna tabela, która pokazuje porównanie trzech najpopularniejszych frameworków do dużych zbiorów danych: Apache Flink, Apache Spark i Apache Hadoop.

	Apache Hadoop	Apache Spark	Apache Flink
Year of Origin	2005	2009	2009
Place of Origin	MapReduce (Google) Hadoop (Yahoo)	Uniwersytet Kalifornijski w Berkeley	Uniwersytet Techniczny w Berlinie
Data Processing Engine	Partia	Partia	Strumień
Processing Speed	Wolniej niż Spark i Flink	100x szybszy niż Hadoop	Szybciej niż iskra
Programming Languages	Java, C, C ++, Ruby, Groovy, Perl, Python	Java, Scala, python i R	Java i Scala
Programming Model	MapReduce	Odporne rozproszone zbiory danych (RDD)	Cykliczne przepływy danych
Data Transfer	Partia	Partia	Rurociągowe i wsadowe
Memory Management	Oparte na dyskach	Zarządzana JVM	Aktywne zarządzane
Latency	Niska	Średni	Niska
Throughput	Średni	Wysoki	Wysoki
Optimization	podręcznik	podręcznik	Automatyczny
API	Niski poziom	Wysoki poziom	Wysoki poziom
Streaming Support	NA	Spark Streaming	Flink Streaming
SQL Support	Rój, Impala	SparkSQL	Tabela API i SQL
Graph Support	NA	GraphX	Gelly
Machine Learning Support	NA	SparkML	FlinkML

Tabela porównawcza, którą widzieliśmy w poprzednim rozdziale, zawiera podsumowanie wskazówek. Apache Flink to najbardziej odpowiedni framework do przetwarzania w czasie rzeczywistym i przypadków użycia. Jego pojedynczy silnik jest wyjątkowy, który może przetwarzać zarówno dane wsadowe, jak i strumieniowe za pomocą różnych interfejsów API, takich jak Dataset i DataStream.

Nie oznacza to, że Hadoop i Spark są poza grą, wybór najbardziej odpowiedniego frameworka Big Data zawsze zależy i różni się w zależności od przypadku użycia. Może istnieć kilka przypadków użycia, w których może być odpowiednia kombinacja Hadoop i Flink lub Spark i Flink.

Niemniej jednak Flink jest obecnie najlepszym frameworkiem do przetwarzania w czasie rzeczywistym. Rozwój Apache Flink był niesamowity, a liczba współtwórców jego społeczności rośnie z dnia na dzień.

Happy Flinking!