Apache Flink - Hızlı Kılavuz

Son 10 yılda verilerin gelişimi muazzam oldu; bu bir 'Büyük Veri' terimine yol açtı. Büyük veri olarak adlandırabileceğiniz sabit veri boyutu yoktur; Geleneksel sisteminizin (RDBMS) işleyemediği herhangi bir veri Büyük Veridir. Bu Büyük Veri, yapılandırılmış, yarı yapılandırılmış veya yapılandırılmamış biçimde olabilir. Başlangıçta, verilerin üç boyutu vardı - Hacim, Hız, Çeşitlilik. Boyutlar artık sadece üç V'nin ötesine geçti. Şimdi başka Vs - Doğruluk, Geçerlilik, Güvenlik Açığı, Değer, Değişkenlik vb. Ekledik.

Büyük Veri, verilerin depolanmasına ve işlenmesine yardımcı olan çok sayıda araç ve çerçevenin ortaya çıkmasına yol açtı. Hadoop, Spark, Hive, Pig, Storm ve Zookeeper gibi birkaç popüler büyük veri çerçevesi vardır. Ayrıca Sağlık Hizmetleri, Finans, Perakende, E-Ticaret ve daha fazlası gibi birden fazla alanda Yeni Nesil ürünler oluşturma fırsatı verdi.

İster bir MNC isterse bir start-up olsun, herkes onu depolamak ve işlemek ve daha akıllı kararlar almak için Büyük Veriden yararlanıyor.

Büyük Veri açısından iki tür işleme vardır -

Toplu İşleme
Gerçek Zamanlı İşleme

Zaman içinde toplanan verilere dayalı işleme Toplu İşleme denir. Örneğin, bir banka yöneticisi son 1 ayda iptal edilen çeklerin sayısını bilmek için son bir aylık verileri (zaman içinde toplanan) işlemek ister.

Anında sonuç için anlık verilere dayalı işlemeye Gerçek Zamanlı İşleme denir. Örneğin, bir dolandırıcılık işlemi (anlık sonuç) gerçekleştikten hemen sonra bir dolandırıcılık uyarısı alan bir banka yöneticisi.

Aşağıda verilen tablo, Toplu İş ve Gerçek Zamanlı İşleme arasındaki farkları listelemektedir -

Toplu İşleme	Gerçek Zamanlı İşleme
Statik Dosyalar	Etkinlik Akışları
Periyodik olarak dakika, saat, gün vb. Olarak işlenir.	Hemen işlendi nanosaniye
Disk depolamadaki geçmiş veriler	Bellek Deposunda
Örnek - Fatura Oluşturma	Örnek - ATM İşlem Uyarısı

Bu günlerde, gerçek zamanlı işleme her kuruluşta çok kullanılıyor. Dolandırıcılık tespiti, sağlık hizmetlerinde gerçek zamanlı uyarılar ve ağ saldırısı uyarısı gibi kullanım durumları, anlık verilerin gerçek zamanlı işlenmesini gerektirir; birkaç milisaniyelik bir gecikme bile çok büyük bir etkiye sahip olabilir.

Bu tür gerçek zamanlı kullanım durumları için ideal bir araç, verileri toplu iş olarak değil akış olarak girebilen araç olacaktır. Apache Flink, gerçek zamanlı işlem aracıdır.

Apache Flink, akış verilerini işleyebilen gerçek zamanlı bir işleme çerçevesidir. Yüksek performanslı, ölçeklenebilir ve doğru gerçek zamanlı uygulamalar için açık kaynaklı bir akış işleme çerçevesidir. Gerçek akış modeline sahiptir ve girdi verilerini toplu veya mikro yığın olarak almaz.

Apache Flink, Data Artisans şirketi tarafından kuruldu ve şimdi Apache Flink Community tarafından Apache Lisansı altında geliştiriliyor. Bu topluluğun şu ana kadar 479'dan fazla katılımcısı ve 15500 + komisyonu var.

Apache Flink'te Ekosistem

Aşağıda verilen diyagram, Apache Flink Ekosisteminin farklı katmanlarını göstermektedir -

Depolama

Apache Flink'in verileri okuyabileceği / yazabileceği birçok seçenek vardır. Aşağıda temel bir depolama listesi bulunmaktadır -

HDFS (Hadoop Dağıtılmış Dosya Sistemi)
Yerel Dosya Sistemi
S3
RDBMS (MySQL, Oracle, MS SQL vb.)
MongoDB
HBase
Apache Kafka
Apache Flume

Dağıtmak

Apache Fink'i yerel modda, küme modunda veya bulutta dağıtabilirsiniz. Küme modu bağımsız, YARN, MESOS olabilir.

Bulutta Flink, AWS veya GCP'de dağıtılabilir.

Çekirdek

Bu, dağıtılmış işleme, hata toleransı, güvenilirlik, yerel yinelemeli işleme yeteneği ve daha fazlasını sağlayan çalışma zamanı katmanıdır.

API'ler ve Kitaplıklar

Bu, Apache Flink'in en üst katmanı ve en önemli katmanıdır. Toplu işlemle ilgilenen Veri Kümesi API'sine ve akış işlemeyle ilgilenen Datastream API'sine sahiptir. Flink ML (makine öğrenimi için), Gelly (grafik işleme için), SQL için Tablolar gibi başka kütüphaneler de vardır. Bu katman, Apache Flink'e çeşitli yetenekler sağlar.

Apache Flink, Kappa mimarisi üzerinde çalışır. Kappa mimarisinde, tüm girdileri akış olarak ele alan ve akış motoru verileri gerçek zamanlı olarak işleyen tek bir işlemci akışına sahiptir. Kappa mimarisindeki toplu veri, özel bir akış durumudur.

Aşağıdaki şema, Apache Flink Architecture.

Kappa mimarisindeki temel fikir, hem toplu hem de gerçek zamanlı verileri tek bir akış işleme motoru aracılığıyla işlemektir.

Çoğu büyük veri çerçevesi, toplu iş ve akış verileri için ayrı işlemcilere sahip Lambda mimarisi üzerinde çalışır. Lambda mimarisinde, toplu iş ve akış görünümleri için ayrı kod tabanlarınız vardır. Sorgulamak ve sonucu almak için kod tabanlarının birleştirilmesi gerekir. Ayrı kod tabanlarını / görünümleri korumamak ve bunları birleştirmek bir acıdır, ancak Kappa mimarisi bu sorunu tek bir görünüme sahip olduğu için çözer - gerçek zamanlı, dolayısıyla kod tabanının birleştirilmesi gerekmez.

Bu, Kappa mimarisinin Lambda mimarisinin yerini aldığı anlamına gelmez, tamamen kullanım durumuna ve hangi mimarinin tercih edileceğine karar veren uygulamaya bağlıdır.

Aşağıdaki diyagram Apache Flink iş yürütme mimarisini göstermektedir.

Program

Flink Kümesi üzerinde çalıştırdığınız bir kod parçasıdır.

Müşteri

Kod (program) almaktan ve iş veri akışı grafiğini oluşturmaktan ve ardından bunu JobManager'a iletmekten sorumludur. Ayrıca İş sonuçlarını da alır.

JobManager

Müşteriden Job Dataflow Grafiğini aldıktan sonra, yürütme grafiğini oluşturmaktan sorumludur. İşi kümedeki TaskManager'lara atar ve işin yürütülmesini denetler.

Görev Yöneticisi

JobManager tarafından atanan tüm görevleri yürütmekten sorumludur. Tüm TaskManager'lar görevleri ayrı yuvalarında belirtilen paralellikte çalıştırır. Görevlerin durumunu JobManager'a göndermek sorumludur.

Apache Flink'in Özellikleri

Apache Flink'in özellikleri aşağıdaki gibidir -

Hem toplu hem de akış programlarını çalıştırabilen bir akış işlemcisine sahiptir.
Verileri yıldırım hızında işleyebilir.
API'ler Java, Scala ve Python'da mevcuttur.
Programcıların kullanması çok kolay olan tüm genel işlemler için API'ler sağlar.
Verileri düşük gecikme (nanosaniye) ve yüksek verimle işler.
Hataya dayanıklıdır. Bir düğüm, uygulama veya donanım arızalanırsa, kümeyi etkilemez.
Apache Hadoop, Apache MapReduce, Apache Spark, HBase ve diğer büyük veri araçlarıyla kolayca entegre edilebilir.
Bellek içi yönetim, daha iyi hesaplama için özelleştirilebilir.
Oldukça ölçeklenebilir ve bir kümede binlerce düğüme kadar ölçeklenebilir.
Apache Flink'te pencereleme çok esnektir.
Grafik İşleme, Makine Öğrenimi, Karmaşık Olay İşleme kütüphaneleri sağlar.

Aşağıdakiler, Apache Flink'i indirmek ve üzerinde çalışmak için sistem gereksinimleridir -

Önerilen İşletim Sistemi

Microsoft Windows 10
Ubuntu 16.04 LTS
Apple macOS 10.13 / Yüksek Sierra

Bellek gereksinimi

Bellek - Minimum 4 GB, Önerilen 8 GB
Depolama Alanı - 30 GB

Note - Java 8, önceden ayarlanmış ortam değişkenleri ile mevcut olmalıdır.

Apache Flink'in kurulum / kurulumuna başlamadan önce, sistemimizde Java 8'in kurulu olup olmadığını kontrol edelim.

Java - sürüm

Şimdi Apache Flink'i indirerek devam edeceğiz.

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

Şimdi, tar dosyasını açın.

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

Flink'in ana dizinine gidin.

cd flink-1.7.1/

Flink Cluster'ı başlatın.

./bin/start-cluster.sh

Mozilla tarayıcısını açın ve aşağıdaki URL'ye gidin, Flink Web Dashboard'u açacaktır.

http://localhost:8081

Apache Flink Dashboard'un Kullanıcı Arayüzü bu şekilde görünür.

Şimdi Flink kümesi hazır ve çalışıyor.

Flink, geliştiricilerin hem toplu hem de gerçek zamanlı veriler üzerinde dönüşüm gerçekleştirebilecekleri zengin bir API kümesine sahiptir. Çeşitli dönüşümler arasında eşleme, filtreleme, sıralama, birleştirme, gruplama ve toplama yer alır. Apache Flink tarafından yapılan bu dönüşümler, dağıtılmış veriler üzerinde gerçekleştirilir. Apache Flink'in sunduğu farklı API'leri tartışalım.

Veri Kümesi API'si

Apache Flink'teki Veri Kümesi API'si, bir dönem boyunca veriler üzerinde toplu işlemler gerçekleştirmek için kullanılır. Bu API Java, Scala ve Python'da kullanılabilir. Filtreleme, haritalama, toplama, birleştirme ve gruplama gibi veri setlerine farklı türlerde dönüşümler uygulayabilir.

Veri kümeleri yerel dosyalar gibi kaynaklardan veya belirli bir kaynaktan bir dosya okunarak oluşturulur ve sonuç verileri, dağıtılmış dosyalar veya komut satırı terminali gibi farklı havuzlara yazılabilir. Bu API hem Java hem de Scala programlama dilleri tarafından desteklenmektedir.

İşte Veri Kümesi API'sinin bir Wordcount programı -

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

Bu API, sürekli akıştaki verileri işlemek için kullanılır. Akış verileri üzerinde filtreleme, eşleme, pencereleme, toplama gibi çeşitli işlemleri gerçekleştirebilirsiniz. Bu veri akışında mesaj kuyrukları, dosyalar, soket akışları gibi çeşitli kaynaklar vardır ve sonuç verileri komut satırı terminali gibi farklı havuzlara yazılabilir. Hem Java hem de Scala programlama dilleri bu API'yi destekler.

Burada, sürekli kelime sayımı akışına sahip olduğunuz ve verilerin ikinci pencerede gruplandırıldığı DataStream API'nin akışlı bir Wordcount programı bulunmaktadır.

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

Tablo API, SQL benzeri ifade diline sahip ilişkisel bir API'dir. Bu API hem toplu hem de akış işlemeyi yapabilir. Java ve Scala Veri Kümesi ve Veri Akışı API'leri ile gömülebilir. Mevcut Veri Kümeleri ve Veri Akışlarından veya harici veri kaynaklarından tablolar oluşturabilirsiniz. Bu ilişkisel API aracılığıyla birleştirme, toplama, seçme ve filtreleme gibi işlemleri gerçekleştirebilirsiniz. Giriş ister toplu iş ister akış olsun, sorgunun anlam bilgisi aynı kalır.

İşte örnek bir Tablo API programı -

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

Bu bölümde, bir Flink uygulamasının nasıl oluşturulacağını öğreneceğiz.

Eclipse IDE'yi açın, Yeni Proje'ye tıklayın ve Java Projesi Seçin.

Proje Adı verin ve Bitir'e tıklayın.

Şimdi, aşağıdaki ekran görüntüsünde gösterildiği gibi Bitir'e tıklayın.

Şimdi sağ tıklayın src ve Yeni >> Sınıfa gidin.

Bir sınıf adı verin ve Bitir'e tıklayın.

Aşağıdaki kodu kopyalayıp Editör'e yapıştırın.

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

Editörde birçok hata alacaksınız çünkü bu projeye Flink kitaplıklarının eklenmesi gerekiyor.

Projeye sağ tıklayın >> Yol Oluştur >> Yapı Yolunu Yapılandır.

Kitaplıklar sekmesini seçin ve Harici JAR Ekle üzerine tıklayın.

Flink'in kitaplık dizinine gidin, 4 kitaplığın hepsini seçin ve Tamam'a tıklayın.

Sırala ve Ver sekmesine gidin, tüm kitaplıkları seçin ve Tamam'a tıklayın.

Artık hataların olmadığını göreceksiniz.

Şimdi bu uygulamayı dışarı aktaralım. Projeye sağ tıklayın ve Dışa Aktar'a tıklayın.

JAR dosyasını seçin ve İleri'ye tıklayın

Bir hedef yol verin ve İleri'ye tıklayın

İleri'ye tıklayın>

Gözat'a tıklayın, ana sınıfı (WordCount) seçin ve Bitir'e tıklayın.

Note - Herhangi bir uyarı almanız durumunda Tamam'ı tıklayın.

Aşağıdaki komutu çalıştırın. Yeni oluşturduğunuz Flink uygulamasını daha da çalıştıracaktır.

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

Bu bölümde, bir Flink programının nasıl çalıştırılacağını öğreneceğiz.

Flink wordcount örneğini bir Flink kümesinde çalıştıralım.

Flink'in ana dizinine gidin ve terminalde aşağıdaki komutu çalıştırın.

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

Flink panosuna gidin, tamamlanmış bir işi ayrıntılarıyla birlikte görebileceksiniz.

Tamamlanan İşler'e tıklarsanız, işlerin ayrıntılı bir özetini alacaksınız.

Wordcount programının çıktısını kontrol etmek için terminalde aşağıdaki komutu çalıştırın.

cat output.txt

Bu bölümde, Apache Flink'in farklı kütüphaneleri hakkında bilgi edineceğiz.

Karmaşık Olay İşleme (CEP)

FlinkCEP, Apache Flink'te bulunan ve sürekli akış verilerindeki olay modellerini analiz eden bir API'dir. Bu olaylar neredeyse gerçek zamanlıdır ve yüksek verim ve düşük gecikmeye sahiptir. Bu API, çoğunlukla gerçek zamanlı olarak gelen ve işlenmesi çok karmaşık olan Sensör verilerinde kullanılır.

CEP, giriş akışının modelini analiz eder ve sonucu çok kısa sürede verir. Olay modelinin karmaşık olması durumunda gerçek zamanlı bildirimler ve uyarılar sağlama yeteneğine sahiptir. FlinkCEP, farklı türdeki giriş kaynaklarına bağlanabilir ve bunların içindeki modelleri analiz edebilir.

CEP ile örnek bir mimari şöyle görünür:

Sensör verileri farklı kaynaklardan gelecek, Kafka, akışları Apache Flink'e dağıtacak dağıtılmış bir mesajlaşma çerçevesi olarak hareket edecek ve FlinkCEP karmaşık olay modellerini analiz edecek.

Pattern API kullanarak karmaşık olay işleme için Apache Flink'te programlar yazabilirsiniz. Sürekli akış verilerinden tespit edilecek olay modellerine karar vermenizi sağlar. Aşağıda en yaygın kullanılan CEP modellerinden bazıları verilmiştir -

Başla

Başlangıç durumunu tanımlamak için kullanılır. Aşağıdaki program bir Flink programında nasıl tanımlandığını göstermektedir -

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

Nerede

Mevcut durumda bir filtre koşulu tanımlamak için kullanılır.

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

Yeni bir model durumunu ve önceki modeli geçmek için gereken eşleştirme olayını eklemek için kullanılır.

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

Bunu takiben

Yeni bir model durumu eklemek için kullanılır, ancak burada diğer olaylar iki eşleşen olay s / b olarak gerçekleşebilir.

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

Gelly

Apache Flink'in Grafik API'si Gelly'dir. Gelly, bir dizi yöntem ve yardımcı program kullanarak Flink uygulamalarında grafik analizi yapmak için kullanılır. Gelly ile dağıtılmış bir şekilde Apache Flink API kullanarak büyük grafikleri analiz edebilirsiniz. Aynı amaç için Apache Giraph gibi başka grafik kitaplıkları da vardır, ancak Gelly Apache Flink'in üstünde kullanıldığından, tek API kullanır. Bu, geliştirme ve operasyon açısından çok faydalıdır.

Apache Flink API - Gelly kullanarak bir örnek çalıştıralım.

Öncelikle, Apache Flink'in opt dizininden lib dizinine 2 Gelly jar dosyasını kopyalamanız gerekir. Sonra flink-gelly-samples jar dosyasını çalıştırın.

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

Şimdi PageRank örneğini çalıştıralım.

PageRank, kenarlar üzerinden iletilen PageRank puanlarının toplamı olan tepe başına bir puanı hesaplar. Her tepe noktasının puanı, kenarlar arasında eşit olarak bölünmüştür. Yüksek puan alan köşeler, diğer yüksek puanlı köşelerle bağlantılıdır.

Sonuç, köşe kimliğini ve PageRank puanını içerir.

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

Apache Flink'in Makine Öğrenimi kitaplığı FlinkML olarak adlandırılır. Makine öğreniminin kullanımı son 5 yılda katlanarak arttığından, Flink topluluğu bu makine öğrenimi APO'sunu kendi ekosistemine de eklemeye karar verdi. Katkıda bulunanların ve algoritmaların listesi FlinkML'de artıyor. Bu API henüz ikili dağıtımın bir parçası değil.

İşte FlinkML kullanan bir doğrusal regresyon örneği -

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

İçeride flink-1.7.1/examples/batch/yol, KMeans.jar dosyasını bulacaksınız. Bu örnek FlinkML örneğini çalıştıralım.

Bu örnek program, varsayılan nokta ve ağırlık merkezi veri kümesi kullanılarak çalıştırılır.

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

Bu bölümde, Apache Flink'teki birkaç test durumunu anlayacağız.

Apache Flink - Bouygues Telecom

Bouygues Telecom, Fransa'daki en büyük telekom kuruluşlarından biridir. 11+ milyon mobil abonesi ve 2.5+ milyon sabit müşterisi var. Bouygues, Paris'te düzenlenen Hadoop Grup Toplantısında ilk kez Apache Flink'i duydu. O zamandan beri birden fazla kullanım durumu için Flink kullanıyorlar. Apache Flink aracılığıyla bir günde milyarlarca mesajı gerçek zamanlı olarak işliyorlar.

Bouygues'in Apache Flink hakkında söylediği şey şudur: " Sistem, hem API hem de çalışma zamanı düzeyinde gerçek akışı desteklediğinden, aradığımız programlanabilirliği ve düşük gecikmeyi bize sağladığı için Flink ile sonuçlandık. Ayrıca, Sistemimizi diğer çözümlere kıyasla çok daha kısa sürede Flink ile çalışır hale getirmeyi başardık, bu da sistemdeki iş mantığını genişletmek için daha fazla kullanılabilir geliştirici kaynağı sağladı. "

Bouygues'de müşteri deneyimi en yüksek önceliktir. Verileri gerçek zamanlı olarak analiz ediyorlar, böylece mühendislerine aşağıdaki bilgileri verebiliyorlar -

Ağları üzerinden Gerçek Zamanlı Müşteri Deneyimi
Ağda küresel olarak neler oluyor
Ağ değerlendirmeleri ve işlemleri

Müşteri deneyimlerini günlüğe kaydedecek ve 60 içinde veri tüketimindeki herhangi bir arızayı tespit etmek için endişe verici bir işlevsellik oluşturacak deneyim kalitesi göstergeleri vermek için dahili veri referansıyla ağ ekipmanından büyük günlük verilerini işleyen LUX (Kayıtlı Kullanıcı Deneyimi) adlı bir sistem oluşturdular. saniye.

Bunu başarmak için, gerçek zamanlı olarak büyük miktarda veri alabilen, kurulumu kolay ve akışlı verileri işlemek için zengin API seti sağlayan bir çerçeveye ihtiyaçları vardı. Apache Flink, Bouygues Telecom için mükemmel bir uyumdu.

Apache Flink - Alibaba

Alibaba, 2015 yılında 394 milyar $ gelirle dünyanın en büyük e-ticaret perakende şirketidir. Alibaba arama, tüm aramaları gösteren ve buna göre tavsiyelerde bulunan tüm müşteriler için giriş noktasıdır.

Alibaba, sonuçları her kullanıcı için en yüksek doğruluk ve alaka düzeyiyle gerçek zamanlı olarak göstermek için arama motorunda Apache Flink'i kullanıyor.

Alibaba bir çerçeve arıyordu ki bu -

Tüm arama altyapısı süreçleri için tek bir kod tabanını sürdürmede çok çevik.
Web sitesinde yer alan ürünlerde kullanılabilirlik değişikliklerinde düşük gecikme sağlar.
Tutarlı ve uygun maliyetli.

Apache Flink, yukarıdaki tüm gereksinimleri karşılamaya hak kazandı. Tek bir işleme motoruna sahip olan ve aynı motorla hem toplu iş hem de akış verilerini işleyebilen bir çerçeveye ihtiyaçları var ve Apache Flink bunu yapıyor.

Ayrıca, aramalarında bazı benzersiz gereksinimleri karşılamak için Flink'in çatallı bir sürümü olan Blink'i kullanıyorlar. Ayrıca, aramaları için birkaç iyileştirme ile Apache Flink'in Tablo API'sini kullanıyorlar.

Alibaba'nın apache Flink hakkında söylediği şey buydu: "Geçmişe baktığımızda, Alibaba'daki Blink ve Flink için kuşkusuz büyük bir yıldı. Hiç kimse bir yıl içinde bu kadar ilerleme kaydedeceğimizi düşünmedi ve hepimize minnettarız toplumda bize yardımcı insanlar. Flink çok büyük ölçekte işe kanıtlanmıştır. Biz daha ileriye FLINK taşımak için toplum ile çalışmalarımızı devam etmek her zamankinden daha kararlıyız! "

En popüler üç büyük veri çerçevesi arasındaki karşılaştırmayı gösteren kapsamlı bir tablo: Apache Flink, Apache Spark ve Apache Hadoop.

	Apache Hadoop	Apache Spark	Apache Flink
Year of Origin	2005	2009	2009
Place of Origin	MapReduce (Google) Hadoop (Yahoo)	California Üniversitesi, Berkeley	Berlin Teknik Üniversitesi
Data Processing Engine	Parti	Parti	Akış
Processing Speed	Spark ve Flink'ten daha yavaş	Hadoop'tan 100 kat daha hızlı	Kıvılcımdan daha hızlı
Programming Languages	Java, C, C ++, Ruby, Groovy, Perl, Python	Java, Scala, python ve R	Java ve Scala
Programming Model	Harita indirgeme	Esnek dağıtılmış Veri Kümeleri (RDD)	Döngüsel veri akışları
Data Transfer	Parti	Parti	Boru Hatlı ve Toplu
Memory Management	Disk Tabanlı	JVM Yönetilen	Aktif Yönetilen
Latency	Düşük	Orta	Düşük
Throughput	Orta	Yüksek	Yüksek
Optimization	Manuel	Manuel	Otomatik
API	Düşük seviye	Yüksek seviye	Yüksek seviye
Streaming Support	NA	Kıvılcım Akışı	Flink Akışı
SQL Support	Kovan, Impala	SparkSQL	Tablo API ve SQL
Graph Support	NA	GraphX	Gelly
Machine Learning Support	NA	SparkML	FlinkML

Önceki bölümde gördüğümüz karşılaştırma tablosu, işaretçileri hemen hemen sonuçlandırıyor. Apache Flink, gerçek zamanlı işleme ve kullanım durumları için en uygun çerçevedir. Dataset ve DataStream gibi farklı API'ler ile hem toplu hem de akış verilerini işleyebilen tek motor sistemi benzersizdir.

Bu, Hadoop ve Spark'ın oyun dışı olduğu anlamına gelmez, en uygun büyük veri çerçevesinin seçimi her zaman bağlıdır ve kullanım durumundan kullanım durumuna göre değişir. Hadoop ve Flink veya Spark ve Flink kombinasyonunun uygun olabileceği birkaç kullanım durumu olabilir.

Bununla birlikte, Flink şu anda gerçek zamanlı işleme için en iyi çerçevedir. Apache Flink'in büyümesi şaşırtıcıydı ve topluluğuna katkıda bulunanların sayısı her geçen gün artıyor.

Mutlu Flinking!