Apache Flink - Guia rápido

O avanço dos dados nos últimos 10 anos foi enorme; isso deu origem ao termo 'Big Data'. Não há tamanho fixo de dados, que você pode chamar de big data; qualquer dado que seu sistema tradicional (RDBMS) não é capaz de manipular é Big Data. Este Big Data pode ser em formato estruturado, semiestruturado ou não estruturado. Inicialmente, havia três dimensões para os dados - Volume, Velocidade, Variedade. As dimensões agora vão além dos três vs. Agora adicionamos outros Vs - Veracidade, Validade, Vulnerabilidade, Valor, Variabilidade, etc.

Big Data levou ao surgimento de múltiplas ferramentas e frameworks que auxiliam no armazenamento e processamento de dados. Existem algumas estruturas de big data populares, como Hadoop, Spark, Hive, Pig, Storm e Zookeeper. Também deu a oportunidade de criar produtos da próxima geração em vários domínios, como saúde, finanças, varejo, comércio eletrônico e muito mais.

Seja uma multinacional ou uma start-up, todos estão aproveitando o Big Data para armazená-lo e processá-lo e tomar decisões mais inteligentes.

Em termos de Big Data, existem dois tipos de processamento -

Processamento em lote
Processamento em tempo real

O processamento com base nos dados coletados ao longo do tempo é chamado de processamento em lote. Por exemplo, um gerente de banco deseja processar os dados do último mês (coletados ao longo do tempo) para saber o número de cheques que foram cancelados no último mês.

O processamento baseado em dados imediatos para resultados instantâneos é chamado de processamento em tempo real. Por exemplo, um gerente de banco recebendo um alerta de fraude imediatamente após a ocorrência de uma transação fraudulenta (resultado instantâneo).

A tabela abaixo lista as diferenças entre o processamento em lote e em tempo real -

Processamento em lote	Processamento em Tempo Real
Arquivos estáticos	Streams de eventos
Processado periodicamente em minuto, hora, dia etc.	Processado imediatamente nanossegundos
Dados anteriores no armazenamento em disco	Armazenamento na memória
Exemplo - Geração de contas	Exemplo - Alerta de transação ATM

Atualmente, o processamento em tempo real está sendo muito usado em todas as organizações. Casos de uso como detecção de fraude, alertas em tempo real na área de saúde e alerta de ataque à rede exigem processamento em tempo real de dados instantâneos; um atraso de até mesmo alguns milissegundos pode ter um grande impacto.

Uma ferramenta ideal para esses casos de uso em tempo real seria aquela, que pode inserir dados como fluxo e não em lote. Apache Flink é essa ferramenta de processamento em tempo real.

Apache Flink é uma estrutura de processamento em tempo real que pode processar dados de streaming. É uma estrutura de processamento de stream de código aberto para aplicativos de tempo real de alto desempenho, escalonáveis e precisos. Possui um modelo de streaming verdadeiro e não aceita dados de entrada como lote ou microlotes.

O Apache Flink foi fundado pela empresa Data Artisans e agora é desenvolvido sob a Licença Apache pela Comunidade Apache Flink. Esta comunidade tem mais de 479 contribuidores e mais de 15500 commits até agora.

Ecossistema no Apache Flink

O diagrama abaixo mostra as diferentes camadas do ecossistema Apache Flink -

Armazenamento

Apache Flink tem várias opções de onde pode ler / gravar dados. Abaixo está uma lista de armazenamento básico -

HDFS (Hadoop Distributed File System)
Sistema de arquivos local
S3
RDBMS (MySQL, Oracle, MS SQL etc.)
MongoDB
HBase
Apache Kafka
Apache Flume

Implantar

Você pode implantar o Apache Fink no modo local, modo de cluster ou na nuvem. O modo de cluster pode ser autônomo, YARN, MESOS.

Na nuvem, o Flink pode ser implantado em AWS ou GCP.

Núcleo

Esta é a camada de tempo de execução, que fornece processamento distribuído, tolerância a falhas, confiabilidade, capacidade de processamento iterativo nativo e muito mais.

APIs e bibliotecas

Esta é a camada superior e a camada mais importante do Apache Flink. Possui API Dataset, que cuida do processamento em lote, e API Datastream, que cuida do processamento de stream. Existem outras bibliotecas como Flink ML (para aprendizado de máquina), Gelly (para processamento de gráficos), Tables for SQL. Esta camada fornece diversos recursos para o Apache Flink.

Apache Flink trabalha na arquitetura Kappa. A arquitetura Kappa possui um único processador - stream, que trata todas as entradas como stream e o mecanismo de streaming processa os dados em tempo real. Os dados em lote na arquitetura kappa são um caso especial de streaming.

O diagrama a seguir mostra o Apache Flink Architecture.

A ideia principal na arquitetura Kappa é lidar com dados em lote e em tempo real por meio de um único mecanismo de processamento de fluxo.

A maior parte da estrutura de big data funciona na arquitetura Lambda, que possui processadores separados para dados em lote e streaming. Na arquitetura Lambda, você tem bases de código separadas para visualizações em lote e fluxo. Para consultar e obter o resultado, as bases de código precisam ser mescladas. Não manter bases de código / visualizações separadas e mesclá-las é uma dor, mas a arquitetura Kappa resolve esse problema, pois tem apenas uma visualização - em tempo real, portanto a mesclagem da base de código não é necessária.

Isso não significa que a arquitetura Kappa substitui a arquitetura Lambda, ela depende completamente do caso de uso e do aplicativo que decide qual arquitetura seria preferível.

O diagrama a seguir mostra a arquitetura de execução de trabalho do Apache Flink.

Programa

É um trecho de código, que você executa no Flink Cluster.

Cliente

Ele é responsável por pegar o código (programa) e construir o gráfico do fluxo de dados do trabalho e, em seguida, passá-lo para o JobManager. Ele também recupera os resultados do trabalho.

JobManager

Após receber o Job Dataflow Graph do Client, ele é responsável por criar o gráfico de execução. Ele atribui o trabalho a TaskManagers no cluster e supervisiona a execução do trabalho.

Gerenciador de tarefas

É responsável por executar todas as tarefas atribuídas pelo JobManager. Todos os TaskManagers executam as tarefas em seus slots separados no paralelismo especificado. É responsável por enviar o status das tarefas ao JobManager.

Recursos do Apache Flink

Os recursos do Apache Flink são os seguintes -

Possui um processador de streaming, que pode executar programas em lote e stream.
Ele pode processar dados em alta velocidade.
APIs disponíveis em Java, Scala e Python.
Fornece APIs para todas as operações comuns, o que é muito fácil para os programadores usarem.
Processa dados em baixa latência (nanossegundos) e alta taxa de transferência.
É tolerante a falhas. Se um nó, aplicativo ou hardware falhar, isso não afetará o cluster.
Pode se integrar facilmente com Apache Hadoop, Apache MapReduce, Apache Spark, HBase e outras ferramentas de big data.
O gerenciamento in-memory pode ser personalizado para melhor computação.
É altamente escalonável e pode escalar até milhares de nós em um cluster.
O janelamento é muito flexível no Apache Flink.
Fornece processamento de gráficos, aprendizado de máquina e bibliotecas de processamento de eventos complexos.

A seguir estão os requisitos do sistema para baixar e trabalhar no Apache Flink -

Sistema operacional recomendado

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

Requisito de Memória

Memória - Mínimo 4 GB, Recomendado 8 GB
Espaço de armazenamento - 30 GB

Note - Java 8 deve estar disponível com variáveis de ambiente já definidas.

Antes de iniciar a configuração / instalação do Apache Flink, vamos verificar se temos o Java 8 instalado em nosso sistema.

Java - versão

Agora prosseguiremos baixando o Apache Flink.

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

Agora, descompacte o arquivo tar.

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

Vá para o diretório inicial do Flink.

cd flink-1.7.1/

Inicie o Flink Cluster.

./bin/start-cluster.sh

Abra o navegador Mozilla e vá para o URL abaixo, ele abrirá o Flink Web Dashboard.

http://localhost:8081

Esta é a aparência da interface do usuário do Apache Flink Dashboard.

Agora o cluster Flink está instalado e funcionando.

Flink tem um rico conjunto de APIs que usam os desenvolvedores para realizar transformações em dados em lote e em tempo real. Uma variedade de transformações inclui mapeamento, filtragem, classificação, junção, agrupamento e agregação. Essas transformações por Apache Flink são realizadas em dados distribuídos. Vamos discutir as diferentes APIs que o Apache Flink oferece.

API Dataset

A API do conjunto de dados no Apache Flink é usada para realizar operações em lote nos dados durante um período. Esta API pode ser usada em Java, Scala e Python. Ele pode aplicar diferentes tipos de transformações nos conjuntos de dados, como filtragem, mapeamento, agregação, junção e agrupamento.

Os conjuntos de dados são criados a partir de fontes como arquivos locais ou pela leitura de um arquivo de um determinado curso e os dados do resultado podem ser gravados em diferentes coletores, como arquivos distribuídos ou terminal de linha de comando. Esta API é compatível com as linguagens de programação Java e Scala.

Aqui está um programa Wordcount da 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

Esta API é usada para lidar com dados em fluxo contínuo. Você pode realizar várias operações, como filtragem, mapeamento, janelamento, agregação de dados de fluxo. Existem várias fontes neste fluxo de dados, como filas de mensagens, arquivos, fluxos de soquete e os dados do resultado podem ser gravados em diferentes coletores, como terminal de linha de comando. As linguagens de programação Java e Scala oferecem suporte a essa API.

Aqui está um programa de streaming de Wordcount da API DataStream, onde você tem um fluxo contínuo de contagens de palavras e os dados são agrupados na segunda janela.

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

A API de tabela é uma API relacional com linguagem de expressão semelhante a SQL. Esta API pode fazer processamento em lote e fluxo. Ele pode ser incorporado com APIs Java e Scala Dataset e Datastream. Você pode criar tabelas de conjuntos de dados e fluxos de dados existentes ou de fontes de dados externas. Por meio dessa API relacional, você pode realizar operações como juntar, agregar, selecionar e filtrar. Quer a entrada seja em lote ou fluxo, a semântica da consulta permanece a mesma.

Aqui está um programa de API de tabela de amostra -

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

Neste capítulo, aprenderemos como criar um aplicativo Flink.

Abra o Eclipse IDE, clique em New Project e Select Java Project.

Dê o nome do projeto e clique em Concluir.

Agora, clique em Concluir conforme mostrado na imagem a seguir.

Agora, clique com o botão direito em src e vá para Novo >> Classe.

Dê um nome para a turma e clique em Concluir.

Copie e cole o código abaixo no 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));
            }
         }
      }
   }
}

Você obterá muitos erros no editor, porque as bibliotecas do Flink precisam ser adicionadas a este projeto.

Clique com o botão direito do mouse no projeto >> Build Path >> Configure Build Path.

Selecione a guia Bibliotecas e clique em Adicionar JARs externos.

Vá para o diretório lib do Flink, selecione todas as 4 bibliotecas e clique em OK.

Vá para a guia Order and Export, selecione todas as bibliotecas e clique em OK.

Você verá que os erros não existem mais.

Agora, vamos exportar este aplicativo. Clique com o botão direito no projeto e clique em Exportar.

Selecione o arquivo JAR e clique em Avançar

Dê um caminho de destino e clique em Avançar

Clique em Avançar>

Clique em Browse, selecione a classe principal (WordCount) e clique em Finish.

Note - Clique em OK, caso receba algum aviso.

Execute o comando abaixo. Ele ainda executará o aplicativo Flink que você acabou de criar.

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

Neste capítulo, aprenderemos como executar um programa Flink.

Vamos executar o exemplo de contagem de palavras do Flink em um cluster do Flink.

Vá para o diretório inicial do Flink e execute o comando abaixo no terminal.

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

Acesse o painel do Flink, você poderá ver um trabalho concluído com seus detalhes.

Se você clicar em Trabalhos concluídos, obterá uma visão geral detalhada dos trabalhos.

Para verificar a saída do programa de contagem de palavras, execute o comando abaixo no terminal.

cat output.txt

Neste capítulo, aprenderemos sobre as diferentes bibliotecas do Apache Flink.

Processamento de Eventos Complexos (CEP)

FlinkCEP é uma API do Apache Flink, que analisa padrões de eventos em dados de streaming contínuo. Esses eventos são quase em tempo real, com alto rendimento e baixa latência. Esta API é usada principalmente em dados do Sensor, que vêm em tempo real e são muito complexos de processar.

O CEP analisa o padrão do fluxo de entrada e dá o resultado muito em breve. Ele tem a capacidade de fornecer notificações e alertas em tempo real caso o padrão do evento seja complexo. O FlinkCEP pode se conectar a diferentes tipos de fontes de entrada e analisar padrões nelas.

É assim que uma arquitetura de amostra com CEP se parece -

Os dados do sensor virão de diferentes fontes, o Kafka atuará como uma estrutura de mensagens distribuída, que distribuirá os fluxos para o Apache Flink e o FlinkCEP analisará os padrões de eventos complexos.

Você pode escrever programas no Apache Flink para processamento de eventos complexos usando a API Pattern. Ele permite que você decida os padrões de eventos a serem detectados nos dados de fluxo contínuo. Abaixo estão alguns dos padrões CEP mais comumente usados -

Início

É usado para definir o estado inicial. O programa a seguir mostra como ele é definido em um programa Flink -

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

Onde

É usado para definir uma condição de filtro no estado atual.

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

É usado para anexar um novo estado de padrão e o evento correspondente necessário para passar o padrão anterior.

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

Seguido por

É usado para anexar um novo estado de padrão, mas aqui outros eventos podem ocorrer b / w dois eventos correspondentes.

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

Gelly

A API Graph do Apache Flink é Gelly. Gelly é usado para realizar análises gráficas em aplicativos Flink usando um conjunto de métodos e utilitários. Você pode analisar gráficos enormes usando a API Apache Flink de maneira distribuída com o Gelly. Existem outras bibliotecas de gráficos também como o Apache Giraph para o mesmo propósito, mas como o Gelly é usado no topo do Apache Flink, ele usa uma API única. Isso é muito útil do ponto de vista de desenvolvimento e operação.

Vamos executar um exemplo usando a API Apache Flink - Gelly.

Em primeiro lugar, você precisa copiar 2 arquivos jar Gelly do diretório opt do Apache Flink para o diretório lib. Em seguida, execute flink-gelly-examples jar.

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

Vamos agora executar o exemplo do PageRank.

O PageRank calcula uma pontuação por vértice, que é a soma das pontuações do PageRank transmitidas nas bordas. A pontuação de cada vértice é dividida igualmente entre as bordas externas. Vértices de alta pontuação são vinculados a outros vértices de alta pontuação.

O resultado contém o ID do vértice e a pontuação do 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

A biblioteca de aprendizado de máquina do Apache Flink é chamada FlinkML. Como o uso de aprendizado de máquina tem aumentado exponencialmente nos últimos 5 anos, a comunidade Flink decidiu adicionar este APO de aprendizado de máquina também em seu ecossistema. A lista de contribuidores e algoritmos está aumentando no FlinkML. Esta API ainda não faz parte da distribuição binária.

Aqui está um exemplo de regressão linear usando 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/caminho, você encontrará o arquivo KMeans.jar. Vamos rodar este exemplo de FlinkML.

Este programa de exemplo é executado usando o ponto padrão e o conjunto de dados do centroide.

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

Neste capítulo, vamos entender alguns casos de teste no Apache Flink.

Apache Flink - Bouygues Telecom

A Bouygues Telecom é uma das maiores organizações de telecomunicações da França. Possui mais de 11 milhões de assinantes móveis e mais de 2,5 milhões de clientes fixos. Bouygues ouviu sobre o Apache Flink pela primeira vez em uma reunião do grupo Hadoop realizada em Paris. Desde então, eles têm usado o Flink para vários casos de uso. Eles têm processado bilhões de mensagens em um dia em tempo real por meio do Apache Flink.

Isso é o que Bouygues tem a dizer sobre o Apache Flink: "Acabamos com o Flink porque o sistema suporta streaming verdadeiro - tanto no nível da API quanto no nível de tempo de execução, dando-nos a programabilidade e baixa latência que estávamos procurando. Além disso, Conseguimos colocar nosso sistema em funcionamento com o Flink em uma fração de tempo em comparação com outras soluções, o que resultou em mais recursos de desenvolvedor disponíveis para expandir a lógica de negócios no sistema. "

Na Bouygues, a experiência do cliente é a maior prioridade. Eles analisam dados em tempo real para que possam fornecer insights a seus engenheiros -

Experiência do cliente em tempo real em sua rede
O que está acontecendo globalmente na rede
Avaliações e operações de rede

Eles criaram um sistema chamado LUX (Logged User Experience) que processou dados massivos de registro de equipamentos de rede com referência de dados internos para fornecer indicadores de qualidade de experiência que registrarão sua experiência do cliente e construirão uma funcionalidade alarmante para detectar qualquer falha no consumo de dados dentro de 60 segundos.

Para conseguir isso, eles precisavam de uma estrutura que pudesse receber dados massivos em tempo real, fosse fácil de configurar e fornecesse um rico conjunto de APIs para processar os dados transmitidos. O Apache Flink era a opção perfeita para a Bouygues Telecom.

Apache Flink - Alibaba

O Alibaba é a maior empresa de varejo de comércio eletrônico do mundo, com receita de US $ 394 bilhões em 2015. A pesquisa do Alibaba é o ponto de entrada para todos os clientes, que mostra todas as pesquisas e recomenda de acordo.

O Alibaba usa o Apache Flink em seu mecanismo de busca para mostrar os resultados em tempo real com a mais alta precisão e relevância para cada usuário.

O Alibaba estava procurando uma estrutura, que era -

Muito ágil na manutenção de uma base de código para todo o processo de infraestrutura de pesquisa.
Fornece baixa latência para as mudanças de disponibilidade dos produtos no site.
Consistente e de baixo custo.

Apache Flink qualificado para todos os requisitos acima. Eles precisam de uma estrutura, que tenha um único mecanismo de processamento e possa processar dados em lote e stream com o mesmo mecanismo e é isso que o Apache Flink faz.

Eles também usam o Blink, uma versão bifurcada do Flink para atender a alguns requisitos exclusivos de sua pesquisa. Eles também estão usando a API de tabela do Apache Flink com algumas melhorias para sua pesquisa.

Isso é o que o Alibaba tinha a dizer sobre o apache Flink: " Olhando para trás, foi sem dúvida um grande ano para Blink e Flink no Alibaba. Ninguém pensou que faríamos tanto progresso em um ano, e estamos muito gratos a todos as pessoas que nos ajudaram na comunidade. Flink provou que trabalha em grande escala. Estamos mais comprometidos do que nunca em continuar nosso trabalho com a comunidade para levar Flink adiante! "

Aqui está uma tabela abrangente, que mostra a comparação entre as três estruturas de big data mais populares: 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)	Universidade da California, Berkeley	Universidade Técnica de Berlim
Data Processing Engine	Lote	Lote	Corrente
Processing Speed	Mais lento que Spark e Flink	100x mais rápido que o Hadoop	Mais rápido que faísca
Programming Languages	Java, C, C ++, Ruby, Groovy, Perl, Python	Java, Scala, python e R	Java e Scala
Programming Model	MapReduce	Conjuntos de dados distribuídos resilientes (RDD)	Fluxos de dados cíclicos
Data Transfer	Lote	Lote	Pipelined e Batch
Memory Management	Baseado em disco	JVM gerenciado	Gerenciado Ativo
Latency	Baixo	Médio	Baixo
Throughput	Médio	Alto	Alto
Optimization	Manual	Manual	Automático
API	Nível baixo	Alto nível	Alto nível
Streaming Support	N / D	Spark Streaming	Flink Streaming
SQL Support	Hive, Impala	SparkSQL	API de tabela e SQL
Graph Support	N / D	GraphX	Gelly
Machine Learning Support	N / D	SparkML	FlinkML

A tabela de comparação que vimos no capítulo anterior conclui muito bem os indicadores. Apache Flink é a estrutura mais adequada para processamento em tempo real e casos de uso. Seu sistema de mecanismo único é único, podendo processar dados em lote e streaming com diferentes APIs, como Dataset e DataStream.

Isso não significa que Hadoop e Spark estão fora do jogo, a seleção da estrutura de big data mais adequada sempre depende e varia de caso de uso para caso de uso. Pode haver vários casos de uso em que uma combinação de Hadoop e Flink ou Spark e Flink pode ser adequada.

No entanto, Flink é a melhor estrutura para processamento em tempo real atualmente. O crescimento do Apache Flink tem sido incrível e o número de colaboradores de sua comunidade cresce a cada dia.

Happy Flinking!