Apache Flink - Guía rápida

El avance de los datos en los últimos 10 años ha sido enorme; esto dio lugar al término 'Big Data'. No hay un tamaño fijo de datos, que pueda llamar como big data; cualquier dato que su sistema tradicional (RDBMS) no pueda manejar es Big Data. Este Big Data puede estar en formato estructurado, semiestructurado o no estructurado. Inicialmente, los datos tenían tres dimensiones: volumen, velocidad, variedad. Las dimensiones ahora han ido más allá de las tres vs. Ahora hemos agregado otras Vs: Veracidad, Validez, Vulnerabilidad, Valor, Variabilidad, etc.

Big Data condujo a la aparición de múltiples herramientas y marcos que ayudan en el almacenamiento y procesamiento de datos. Hay algunos marcos de big data populares como Hadoop, Spark, Hive, Pig, Storm y Zookeeper. También brindó la oportunidad de crear productos de próxima generación en múltiples dominios como salud, finanzas, venta minorista, comercio electrónico y más.

Tanto si se trata de una multinacional como de una empresa emergente, todo el mundo aprovecha el Big Data para almacenarlo, procesarlo y tomar decisiones más inteligentes.

En términos de Big Data, existen dos tipos de procesamiento:

Procesamiento por lotes
Procesamiento en tiempo real

El procesamiento basado en los datos recopilados a lo largo del tiempo se denomina procesamiento por lotes. Por ejemplo, el gerente de un banco desea procesar los datos del último mes (recopilados a lo largo del tiempo) para saber la cantidad de cheques que se cancelaron en el último mes.

El procesamiento basado en datos inmediatos para obtener resultados instantáneos se denomina procesamiento en tiempo real. Por ejemplo, el gerente de un banco recibe una alerta de fraude inmediatamente después de que se ha producido una transacción de fraude (resultado instantáneo).

La tabla que se proporciona a continuación enumera las diferencias entre el procesamiento por lotes y el procesamiento en tiempo real:

Procesamiento por lotes	Procesamiento en tiempo real
Archivos estáticos	Flujos de eventos
Procesado periódicamente en minutos, horas, días, etc.	Procesado inmediatamente nanosegundos
Datos anteriores sobre almacenamiento en disco	En almacenamiento de memoria
Ejemplo: generación de facturas	Ejemplo: alerta de transacción de cajero automático

En estos días, el procesamiento en tiempo real se utiliza mucho en todas las organizaciones. Los casos de uso como la detección de fraudes, las alertas en tiempo real en el cuidado de la salud y las alertas de ataques a la red requieren un procesamiento en tiempo real de datos instantáneos; un retraso de incluso unos pocos milisegundos puede tener un gran impacto.

Una herramienta ideal para estos casos de uso en tiempo real sería la que puede ingresar datos como flujo y no por lotes. Apache Flink es esa herramienta de procesamiento en tiempo real.

Apache Flink es un marco de procesamiento en tiempo real que puede procesar datos de transmisión. Es un marco de procesamiento de flujo de código abierto para aplicaciones de alto rendimiento, escalables y precisas en tiempo real. Tiene un modelo de transmisión real y no toma datos de entrada como lotes o micro lotes.

Apache Flink fue fundado por la empresa Data Artisans y ahora se desarrolla bajo la licencia Apache por Apache Flink Community. Esta comunidad tiene más de 479 colaboradores y más de 15500 confirmaciones hasta ahora.

Ecosistema en Apache Flink

El diagrama que se muestra a continuación muestra las diferentes capas del ecosistema Apache Flink:

Almacenamiento

Apache Flink tiene múltiples opciones desde donde puede leer / escribir datos. A continuación se muestra una lista de almacenamiento básica:

HDFS (sistema de archivos distribuido Hadoop)
Sistema de archivos local
S3
RDBMS (MySQL, Oracle, MS SQL, etc.)
MongoDB
HBase
Apache Kafka
Apache Flume

Desplegar

Puede implementar Apache Fink en modo local, modo de clúster o en la nube. El modo de clúster puede ser independiente, YARN, MESOS.

En la nube, Flink se puede implementar en AWS o GCP.

Núcleo

Esta es la capa de tiempo de ejecución, que proporciona procesamiento distribuido, tolerancia a fallas, confiabilidad, capacidad de procesamiento iterativo nativo y más.

API y bibliotecas

Esta es la capa superior y la capa más importante de Apache Flink. Tiene API de conjunto de datos, que se encarga del procesamiento por lotes, y API de Datastream, que se encarga del procesamiento de la transmisión. Hay otras bibliotecas como Flink ML (para aprendizaje automático), Gelly (para procesamiento de gráficos), Tablas para SQL. Esta capa proporciona diversas capacidades a Apache Flink.

Apache Flink funciona en la arquitectura Kappa. La arquitectura Kappa tiene un solo procesador: flujo, que trata todas las entradas como flujo y el motor de flujo procesa los datos en tiempo real. Los datos por lotes en la arquitectura kappa son un caso especial de transmisión.

El siguiente diagrama muestra el Apache Flink Architecture.

La idea clave en la arquitectura de Kappa es manejar datos por lotes y en tiempo real a través de un motor de procesamiento de flujo único.

La mayoría de los marcos de big data funcionan en la arquitectura Lambda, que tiene procesadores separados para datos por lotes y de transmisión. En la arquitectura Lambda, tiene bases de código independientes para las vistas por lotes y por secuencias. Para consultar y obtener el resultado, las bases de código deben fusionarse. No mantener bases de código / vistas separadas y fusionarlas es una molestia, pero la arquitectura Kappa resuelve este problema ya que solo tiene una vista: en tiempo real, por lo que no es necesario fusionar la base de código.

Eso no significa que la arquitectura Kappa reemplace la arquitectura Lambda, depende completamente del caso de uso y de la aplicación que decide qué arquitectura sería preferible.

El siguiente diagrama muestra la arquitectura de ejecución de trabajos de Apache Flink.

Programa

Es un fragmento de código que se ejecuta en Flink Cluster.

Cliente

Es responsable de tomar el código (programa) y construir el gráfico de flujo de datos del trabajo, luego pasarlo a JobManager. También recupera los resultados del trabajo.

JobManager

Después de recibir el gráfico de flujo de datos del trabajo del cliente, es responsable de crear el gráfico de ejecución. Asigna el trabajo a los TaskManagers en el clúster y supervisa la ejecución del trabajo.

Administrador de tareas

Es el encargado de ejecutar todas las tareas que le haya asignado JobManager. Todos los TaskManagers ejecutan las tareas en sus ranuras separadas en un paralelismo especificado. Es responsable de enviar el estado de las tareas a JobManager.

Características de Apache Flink

Las características de Apache Flink son las siguientes:

Tiene un procesador de transmisión, que puede ejecutar programas tanto por lotes como por transmisión.
Puede procesar datos a la velocidad del rayo.
API disponibles en Java, Scala y Python.
Proporciona API para todas las operaciones comunes, que es muy fácil de usar para los programadores.
Procesa datos en baja latencia (nanosegundos) y alto rendimiento.
Es tolerante a fallas. Si un nodo, una aplicación o un hardware falla, no afecta al clúster.
Puede integrarse fácilmente con Apache Hadoop, Apache MapReduce, Apache Spark, HBase y otras herramientas de big data.
La gestión en memoria se puede personalizar para un mejor cálculo.
Es altamente escalable y puede escalar hasta miles de nodos en un clúster.
La creación de ventanas es muy flexible en Apache Flink.
Proporciona bibliotecas de procesamiento de gráficos, aprendizaje automático y procesamiento de eventos complejos.

Los siguientes son los requisitos del sistema para descargar y trabajar en Apache Flink:

Sistema operativo recomendado

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

Requisito de memoria

Memoria: mínimo 4 GB, recomendado 8 GB
Espacio de almacenamiento: 30 GB

Note - Java 8 debe estar disponible con las variables de entorno ya configuradas.

Antes de comenzar con la configuración / instalación de Apache Flink, verifiquemos si tenemos Java 8 instalado en nuestro sistema.

Java - versión

Ahora procederemos a descargar Apache Flink.

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

Ahora, descomprima el archivo tar.

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

Vaya al directorio de inicio de Flink.

cd flink-1.7.1/

Inicie el Flink Cluster.

./bin/start-cluster.sh

Abra el navegador Mozilla y vaya a la siguiente URL, se abrirá el Panel de control web de Flink.

http://localhost:8081

Así es como se ve la interfaz de usuario de Apache Flink Dashboard.

Ahora el clúster de Flink está en funcionamiento.

Flink tiene un amplio conjunto de API con las que los desarrolladores pueden realizar transformaciones tanto en datos por lotes como en tiempo real. Una variedad de transformaciones incluye mapeo, filtrado, clasificación, unión, agrupación y agregación. Estas transformaciones de Apache Flink se realizan en datos distribuidos. Analicemos las diferentes API que ofrece Apache Flink.

API de conjunto de datos

La API de conjunto de datos en Apache Flink se utiliza para realizar operaciones por lotes en los datos durante un período. Esta API se puede utilizar en Java, Scala y Python. Puede aplicar diferentes tipos de transformaciones en los conjuntos de datos como filtrar, mapear, agregar, unir y agrupar.

Los conjuntos de datos se crean a partir de fuentes como archivos locales o mediante la lectura de un archivo de una fuente en particular y los datos de resultado se pueden escribir en diferentes sumideros, como archivos distribuidos o terminales de línea de comandos. Esta API es compatible con los lenguajes de programación Java y Scala.

Aquí hay un programa Wordcount de Dataset API:

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 de DataStream

Esta API se utiliza para manejar datos en flujo continuo. Puede realizar varias operaciones como filtrado, mapeo, creación de ventanas, agregación en los datos del flujo. Hay varias fuentes en este flujo de datos como colas de mensajes, archivos, flujos de sockets y los datos de resultado se pueden escribir en diferentes sumideros como el terminal de línea de comandos. Los lenguajes de programación Java y Scala admiten esta API.

Aquí hay un programa Wordcount de flujo continuo de la API DataStream, donde tiene un flujo continuo de recuentos de palabras y los datos se agrupan en la segunda ventana.

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 es una API relacional con lenguaje de expresión similar a SQL. Esta API puede procesar tanto por lotes como por secuencias. Puede integrarse con Java y Scala Dataset y API de Datastream. Puede crear tablas a partir de conjuntos de datos y flujos de datos existentes o de fuentes de datos externas. A través de esta API relacional, puede realizar operaciones como unir, agregar, seleccionar y filtrar. Ya sea que la entrada sea por lotes o en flujo, la semántica de la consulta sigue siendo la misma.

Aquí hay un programa de API de tabla de muestra:

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

En este capítulo, aprenderemos cómo crear una aplicación Flink.

Abra Eclipse IDE, haga clic en Nuevo proyecto y seleccione Proyecto Java.

Dé el nombre del proyecto y haga clic en Finalizar.

Ahora, haga clic en Finalizar como se muestra en la siguiente captura de pantalla.

Ahora, haga clic derecho en src y vaya a Nueva >> Clase.

Dé un nombre de clase y haga clic en Finalizar.

Copie y pegue el siguiente código en el 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));
            }
         }
      }
   }
}

Obtendrá muchos errores en el editor, porque las bibliotecas de Flink deben agregarse a este proyecto.

Haga clic con el botón derecho en el proyecto >> Ruta de compilación >> Configurar ruta de compilación.

Seleccione la pestaña Bibliotecas y haga clic en Agregar JAR externos.

Vaya al directorio de bibliotecas de Flink, seleccione las 4 bibliotecas y haga clic en Aceptar.

Vaya a la pestaña Solicitar y exportar, seleccione todas las bibliotecas y haga clic en Aceptar.

Verás que los errores ya no existen.

Ahora, exportemos esta aplicación. Haga clic derecho en el proyecto y haga clic en Exportar.

Seleccione el archivo JAR y haga clic en Siguiente

Dé una ruta de destino y haga clic en Siguiente

Haga clic en Siguiente>

Haga clic en Examinar, seleccione la clase principal (WordCount) y haga clic en Finalizar.

Note - Haga clic en Aceptar, en caso de que reciba alguna advertencia.

Ejecute el siguiente comando. Además, ejecutará la aplicación Flink que acaba de crear.

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

En este capítulo, aprenderemos cómo ejecutar un programa Flink.

Ejecutemos el ejemplo de conteo de palabras de Flink en un clúster de Flink.

Vaya al directorio de inicio de Flink y ejecute el siguiente comando en la terminal.

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

Vaya al panel de Flink, podrá ver un trabajo completado con sus detalles.

Si hace clic en Trabajos completados, obtendrá una descripción detallada de los trabajos.

Para verificar la salida del programa de conteo de palabras, ejecute el siguiente comando en la terminal.

cat output.txt

En este capítulo, aprenderemos sobre las diferentes bibliotecas de Apache Flink.

Procesamiento de eventos complejos (CEP)

FlinkCEP es una API en Apache Flink, que analiza patrones de eventos en datos de transmisión continua. Estos eventos son casi en tiempo real, que tienen un alto rendimiento y baja latencia. Esta API se utiliza principalmente en datos de sensores, que vienen en tiempo real y son muy complejos de procesar.

CEP analiza el patrón del flujo de entrada y da el resultado muy pronto. Tiene la capacidad de proporcionar notificaciones y alertas en tiempo real en caso de que el patrón de eventos sea complejo. FlinkCEP puede conectarse a diferentes tipos de fuentes de entrada y analizar patrones en ellas.

Así se ve una arquitectura de muestra con CEP:

Los datos del sensor vendrán de diferentes fuentes, Kafka actuará como un marco de mensajería distribuida, que distribuirá las transmisiones a Apache Flink, y FlinkCEP analizará los patrones de eventos complejos.

Puede escribir programas en Apache Flink para el procesamiento de eventos complejos utilizando Pattern API. Le permite decidir los patrones de eventos a detectar a partir de los datos de flujo continuo. A continuación se muestran algunos de los patrones CEP más utilizados:

Empezar

Se utiliza para definir el estado inicial. El siguiente programa muestra cómo se define en un programa Flink:

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

Dónde

Se utiliza para definir una condición de filtro en el estado actual.

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

Se utiliza para agregar un nuevo estado de patrón y el evento coincidente necesario para pasar el patrón anterior.

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

Seguido por

Se usa para agregar un nuevo estado de patrón, pero aquí pueden ocurrir otros eventos b / w dos eventos coincidentes.

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

Gelly

La API Graph de Apache Flink es Gelly. Gelly se utiliza para realizar análisis de gráficos en aplicaciones Flink utilizando un conjunto de métodos y utilidades. Puede analizar grandes gráficos utilizando Apache Flink API de forma distribuida con Gelly. Hay otras bibliotecas de gráficos también como Apache Giraph para el mismo propósito, pero como Gelly se usa sobre Apache Flink, usa una API única. Esto es muy útil desde el punto de vista del desarrollo y la operación.

Ejecutemos un ejemplo usando Apache Flink API - Gelly.

En primer lugar, debe copiar 2 archivos jar de Gelly desde el directorio opt de Apache Flink a su directorio lib. Luego ejecute flink-gelly-examples jar.

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

Ejecutemos ahora el ejemplo de PageRank.

PageRank calcula una puntuación por vértice, que es la suma de las puntuaciones de PageRank transmitidas por los bordes. La puntuación de cada vértice se divide uniformemente entre los bordes. Los vértices de alta puntuación están vinculados a otros vértices de alta puntuación.

El resultado contiene el ID de vértice y la puntuación de 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 biblioteca de aprendizaje automático de Apache Flink se llama FlinkML. Dado que el uso del aprendizaje automático ha aumentado exponencialmente durante los últimos 5 años, la comunidad de Flink decidió agregar esta APO de aprendizaje automático también en su ecosistema. La lista de contribuyentes y algoritmos está aumentando en FlinkML. Esta API aún no forma parte de la distribución binaria.

Aquí hay un ejemplo de regresión lineal 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/ruta, encontrará el archivo KMeans.jar. Ejecutemos este ejemplo de muestra de FlinkML.

Este programa de ejemplo se ejecuta utilizando el punto predeterminado y el conjunto de datos del centroide.

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

En este capítulo, comprenderemos algunos casos de prueba en Apache Flink.

Apache Flink - Bouygues Telecom

Bouygues Telecom es una de las organizaciones de telecomunicaciones más grandes de Francia. Tiene más de 11 millones de suscriptores móviles y más de 2,5 millones de clientes fijos. Bouygues escuchó hablar de Apache Flink por primera vez en una reunión del Grupo Hadoop celebrada en París. Desde entonces, han estado usando Flink para múltiples casos de uso. Han estado procesando miles de millones de mensajes en un día en tiempo real a través de Apache Flink.

Esto es lo que Bouygues tiene que decir sobre Apache Flink: "Terminamos con Flink porque el sistema admite transmisión real, tanto en la API como en el nivel de tiempo de ejecución, lo que nos brinda la capacidad de programación y la baja latencia que estábamos buscando. Además, pudimos poner nuestro sistema en funcionamiento con Flink en una fracción del tiempo en comparación con otras soluciones, lo que resultó en más recursos de desarrollo disponibles para expandir la lógica empresarial en el sistema ".

En Bouygues, la experiencia del cliente es la máxima prioridad. Analizan datos en tiempo real para que puedan brindar información a sus ingenieros a continuación:

Experiencia del cliente en tiempo real a través de su red
Qué está sucediendo a nivel mundial en la red
Evaluaciones y operaciones de la red

Crearon un sistema llamado LUX (Logged User Experience) que procesaba datos de registro masivos de equipos de red con referencia de datos internos para brindar indicadores de calidad de experiencia que registrarán la experiencia del cliente y construirán una funcionalidad alarmante para detectar cualquier falla en el consumo de datos dentro de 60 segundos.

Para lograr esto, necesitaban un marco que pueda tomar datos masivos en tiempo real, sea fácil de configurar y proporcione un amplio conjunto de API para procesar los datos transmitidos. Apache Flink encajaba perfectamente con Bouygues Telecom.

Apache Flink - Alibaba

Alibaba es la empresa minorista de comercio electrónico más grande del mundo con 394 mil millones de dólares de ingresos en 2015. La búsqueda de Alibaba es el punto de entrada a todos los clientes, que muestra toda la búsqueda y recomienda en consecuencia.

Alibaba utiliza Apache Flink en su motor de búsqueda para mostrar resultados en tiempo real con la mayor precisión y relevancia para cada usuario.

Alibaba estaba buscando un marco, que era ...

Muy ágil en el mantenimiento de una base de código para todo el proceso de infraestructura de búsqueda.
Proporciona baja latencia para los cambios de disponibilidad en los productos en el sitio web.
Consistente y rentable.

Apache Flink calificó para todos los requisitos anteriores. Necesitan un marco, que tenga un solo motor de procesamiento y pueda procesar tanto datos por lotes como en flujo con el mismo motor, y eso es lo que hace Apache Flink.

También usan Blink, una versión bifurcada de Flink para cumplir con algunos requisitos únicos para su búsqueda. También están utilizando Table API de Apache Flink con pocas mejoras para su búsqueda.

Esto es lo que Alibaba dijo sobre apache Flink: " Mirando hacia atrás, sin duda fue un gran año para Blink y Flink en Alibaba. Nadie pensó que haríamos tanto progreso en un año, y estamos muy agradecidos con todos las personas que nos ayudaron en la comunidad. Se ha demostrado que Flink trabaja a gran escala. ¡Estamos más comprometidos que nunca a continuar nuestro trabajo con la comunidad para hacer avanzar a Flink! "

Aquí hay una tabla completa, que muestra la comparación entre los tres frameworks de big data más populares: Apache Flink, Apache Spark y Apache Hadoop.

	Apache Hadoop	Apache Spark	Apache Flink
Year of Origin	2005	2009	2009
Place of Origin	MapReduce (Google) Hadoop (Yahoo)	Universidad de California, Berkeley	Universidad Técnica de Berlín
Data Processing Engine	Lote	Lote	Corriente
Processing Speed	Más lento que Spark y Flink	100 veces más rápido que Hadoop	Más rápido que la chispa
Programming Languages	Java, C, C ++, Ruby, Groovy, Perl, Python	Java, Scala, python y R	Java y Scala
Programming Model	Mapa reducido	Conjuntos de datos distribuidos resilientes (RDD)	Flujos de datos cíclicos
Data Transfer	Lote	Lote	Canalizado y por lotes
Memory Management	Basado en disco	JVM gestionado	Activo gestionado
Latency	Bajo	Medio	Bajo
Throughput	Medio	Alto	Alto
Optimization	Manual	Manual	Automático
API	Nivel bajo	Nivel alto	Nivel alto
Streaming Support	N / A	Spark Streaming	Flink Streaming
SQL Support	Colmena, Impala	SparkSQL	API de tabla y SQL
Graph Support	N / A	GraphX	Gelly
Machine Learning Support	N / A	SparkML	FlinkML

La tabla de comparación que vimos en el capítulo anterior concluye bastante los indicadores. Apache Flink es el marco más adecuado para casos de uso y procesamiento en tiempo real. Su sistema de motor único es único y puede procesar tanto datos por lotes como en streaming con diferentes API como Dataset y DataStream.

No significa que Hadoop y Spark estén fuera del juego, la selección del marco de big data más adecuado siempre depende y varía de un caso de uso a otro. Puede haber varios casos de uso en los que una combinación de Hadoop y Flink o Spark y Flink podría ser adecuada.

Sin embargo, Flink es el mejor marco para el procesamiento en tiempo real actualmente. El crecimiento de Apache Flink ha sido asombroso y la cantidad de contribuyentes a su comunidad crece día a día.

¡Feliz parpadeo!