sql >> Base de Datos >  >> RDS >> PostgreSQL

Big Data con PostgreSQL y Apache Spark

PostgreSQL es bien conocido como la base de datos de código abierto más avanzada y lo ayuda a administrar sus datos sin importar cuán grande, pequeño o diferente sea el conjunto de datos, por lo que puede usarlo para administrar o analizar su gran cantidad de datos y, por supuesto, hay varias formas de hacer esto posible, por ejemplo, Apache Spark. En este blog, veremos qué es Apache Spark y cómo podemos usarlo para trabajar con nuestra base de datos PostgreSQL.

Para el análisis de big data, tenemos dos tipos diferentes de análisis:

  • Análisis por lotes:basado en los datos recopilados durante un período de tiempo.
  • Análisis (flujo) en tiempo real:basado en datos inmediatos para un resultado instantáneo.

¿Qué es Apache Spark?

Apache Spark es un motor de análisis unificado para el procesamiento de datos a gran escala que puede funcionar en análisis por lotes y en tiempo real de una manera más rápida y sencilla.

Proporciona API de alto nivel en Java, Scala, Python y R, y un motor optimizado que admite gráficos de ejecución general.

Componentes de Apache Spark

Bibliotecas de Apache Spark

Apache Spark incluye diferentes bibliotecas:

  • Spark SQL:es un módulo para trabajar con datos estructurados usando SQL o una API DataFrame. Proporciona una forma común de acceder a una variedad de orígenes de datos, incluidos Hive, Avro, Parquet, ORC, JSON y JDBC. Incluso puede unir datos de estas fuentes.
  • Spark Streaming:facilita la creación de aplicaciones de transmisión tolerantes a fallas escalables mediante una API integrada en el lenguaje para el procesamiento de transmisión, lo que le permite escribir trabajos de transmisión de la misma manera que escribe trabajos por lotes. Es compatible con Java, Scala y Python. Spark Streaming recupera tanto el trabajo perdido como el estado del operador de forma inmediata, sin ningún código adicional de su parte. Le permite reutilizar el mismo código para el procesamiento por lotes, unir secuencias con datos históricos o ejecutar consultas ad-hoc en el estado de la secuencia.
  • MLib (aprendizaje automático):es una biblioteca escalable de aprendizaje automático. MLlib contiene algoritmos de alta calidad que aprovechan la iteración y pueden generar mejores resultados que las aproximaciones de un solo paso que a veces se usan en MapReduce.
  • GraphX:es una API para gráficos y computación paralela de gráficos. GraphX ​​unifica ETL, el análisis exploratorio y el cálculo iterativo de gráficos en un solo sistema. Puede ver los mismos datos como gráficos y colecciones, transformar y unir gráficos con RDD de manera eficiente y escribir algoritmos de gráficos iterativos personalizados utilizando la API de Pregel.

Ventajas de Apache Spark

Según la documentación oficial, algunas ventajas de Apache Spark son:

  • Velocidad:ejecute cargas de trabajo 100 veces más rápido. Apache Spark logra un alto rendimiento tanto para datos por lotes como de transmisión, utilizando un programador DAG (Gráfico acíclico directo) de última generación, un optimizador de consultas y un motor de ejecución física.
  • Facilidad de uso:escriba aplicaciones rápidamente en Java, Scala, Python, R y SQL. Spark ofrece más de 80 operadores de alto nivel que facilitan la creación de aplicaciones paralelas. Puede usarlo de forma interactiva desde los shells de Scala, Python, R y SQL.
  • Generalidad:combine SQL, transmisión y análisis complejo. Spark impulsa una pila de bibliotecas que incluyen SQL y DataFrames, MLlib para aprendizaje automático, GraphX ​​y Spark Streaming. Puede combinar estas bibliotecas sin problemas en la misma aplicación.
  • Se ejecuta en todas partes:Spark se ejecuta en Hadoop, Apache Mesos, Kubernetes, de forma independiente o en la nube. Puede acceder a diversas fuentes de datos. Puede ejecutar Spark con su modo de clúster independiente, en EC2, en Hadoop YARN, en Mesos o en Kubernetes. Acceda a datos en HDFS, Alluxio, Apache Cassandra, Apache HBase, Apache Hive y cientos de otras fuentes de datos.

Ahora, veamos cómo podemos integrar esto con nuestra base de datos PostgreSQL.

Cómo usar Apache Spark con PostgreSQL

Asumiremos que tiene su clúster de PostgreSQL en funcionamiento. Para esta tarea, usaremos un servidor PostgreSQL 11 que se ejecuta en CentOS7.

Primero, creemos nuestra base de datos de prueba en nuestro servidor PostgreSQL:

postgres=# CREATE DATABASE testing;
CREATE DATABASE
postgres=# \c testing
You are now connected to database "testing" as user "postgres".

Ahora, vamos a crear una tabla llamada t1:

testing=# CREATE TABLE t1 (id int, name text);
CREATE TABLE

E inserte algunos datos allí:

testing=# INSERT INTO t1 VALUES (1,'name1');
INSERT 0 1
testing=# INSERT INTO t1 VALUES (2,'name2');
INSERT 0 1

Verifique los datos creados:

testing=# SELECT * FROM t1;
 id | name
----+-------
  1 | name1
  2 | name2
(2 rows)

Para conectar Apache Spark a nuestra base de datos PostgreSQL, usaremos un conector JDBC. Puedes descargarlo desde aquí.

$ wget https://jdbc.postgresql.org/download/postgresql-42.2.6.jar

Ahora, instalemos Apache Spark. Para esto, necesitamos descargar los paquetes Spark desde aquí.

$ wget http://us.mirrors.quenda.co/apache/spark/spark-2.4.3/spark-2.4.3-bin-hadoop2.7.tgz
$ tar zxvf spark-2.4.3-bin-hadoop2.7.tgz
$ cd spark-2.4.3-bin-hadoop2.7/

Para ejecutar Spark Shell, necesitaremos tener JAVA instalado en nuestro servidor:

$  yum install java

Ahora, podemos ejecutar nuestro Spark Shell:

$ ./bin/spark-shell
Using Spark's default log4j profile: org/apache/spark/log4j-defaults.properties
Setting default log level to "WARN".
To adjust logging level use sc.setLogLevel(newLevel). For SparkR, use setLogLevel(newLevel).
Spark context Web UI available at http://ApacheSpark1:4040
Spark context available as 'sc' (master = local[*], app id = local-1563907528854).
Spark session available as 'spark'.
Welcome to
      ____              __
     / __/__  ___ _____/ /__
    _\ \/ _ \/ _ `/ __/  '_/
   /___/ .__/\_,_/_/ /_/\_\   version 2.4.3
      /_/

Using Scala version 2.11.12 (OpenJDK 64-Bit Server VM, Java 1.8.0_212)
Type in expressions to have them evaluated.
Type :help for more information.

scala>

Podemos acceder a nuestra interfaz de usuario web de contexto Spark disponible en el puerto 4040 en nuestro servidor:

Interfaz de usuario de Apache Spark

En el shell de Spark, debemos agregar el controlador JDBC de PostgreSQL:

scala> :require /path/to/postgresql-42.2.6.jar
Added '/path/to/postgresql-42.2.6.jar' to classpath.
scala> import java.util.Properties
import java.util.Properties

Y agregue la información de JDBC que usará Spark:

scala> val url = "jdbc:postgresql://localhost:5432/testing"
url: String = jdbc:postgresql://localhost:5432/testing
scala> val connectionProperties = new Properties()
connectionProperties: java.util.Properties = {}
scala> connectionProperties.setProperty("Driver", "org.postgresql.Driver")
res6: Object = null

Ahora, podemos ejecutar consultas SQL. Primero, definamos query1 como SELECT * FROM t1, nuestra tabla de prueba.

scala> val query1 = "(SELECT * FROM t1) as q1"
query1: String = (SELECT * FROM t1) as q1

Y crea el DataFrame:

scala> val query1df = spark.read.jdbc(url, query1, connectionProperties)
query1df: org.apache.spark.sql.DataFrame = [id: int, name: string]

Ahora, podemos realizar una acción sobre este DataFrame:

scala> query1df.show()
+---+-----+
| id| name|
+---+-----+
|  1|name1|
|  2|name2|
+---+-----+
scala> query1df.explain
== Physical Plan ==
*(1) Scan JDBCRelation((SELECT * FROM t1) as q1) [numPartitions=1] [id#19,name#20] PushedFilters: [], ReadSchema: struct<id:int,name:string>

Podemos agregar más valores y ejecutarlo nuevamente solo para confirmar que está devolviendo los valores actuales.

PostgreSQL

testing=# INSERT INTO t1 VALUES (10,'name10'), (11,'name11'), (12,'name12'), (13,'name13'), (14,'name14'), (15,'name15');
INSERT 0 6
testing=# SELECT * FROM t1;
 id |  name
----+--------
  1 | name1
  2 | name2
 10 | name10
 11 | name11
 12 | name12
 13 | name13
 14 | name14
 15 | name15
(8 rows)

Chispa

scala> query1df.show()
+---+------+
| id|  name|
+---+------+
|  1| name1|
|  2| name2|
| 10|name10|
| 11|name11|
| 12|name12|
| 13|name13|
| 14|name14|
| 15|name15|
+---+------+

En nuestro ejemplo, solo mostramos cómo funciona Apache Spark con nuestra base de datos PostgreSQL, no cómo administra nuestra información de Big Data.

Conclusión

Hoy en día, es bastante común tener el desafío de administrar big data en una empresa y, como pudimos ver, podemos usar Apache Spark para enfrentarlo y hacer uso de todas las características que mencionamos anteriormente. Big data es un mundo enorme, por lo que puede consultar la documentación oficial para obtener más información sobre el uso de Apache Spark y PostgreSQL y adaptarlo a sus requisitos.