Big Data met PostgreSQL en Apache Spark

PostgreSQL staat bekend als de meest geavanceerde opensource-database en het helpt u bij het beheren van uw gegevens, hoe groot, klein of verschillend de gegevensset ook is, zodat u deze kunt gebruiken om uw grote gegevens te beheren of analyseren, en natuurlijk zijn er verschillende manieren om dit mogelijk te maken, bijvoorbeeld Apache Spark. In deze blog zullen we zien wat Apache Spark is en hoe we het kunnen gebruiken om met onze PostgreSQL-database te werken.

Voor big data-analyse hebben we twee verschillende soorten analyses:

Batchanalyse:gebaseerd op de gegevens die gedurende een bepaalde periode zijn verzameld.
Realtime (stream)analyse:op basis van directe gegevens voor direct resultaat.

Wat is Apache Spark?

Apache Spark is een uniforme analyse-engine voor grootschalige gegevensverwerking die sneller en gemakkelijker kan werken aan zowel batch- als realtime analyses.

Het biedt hoogwaardige API's in Java, Scala, Python en R, en een geoptimaliseerde engine die algemene uitvoeringsgrafieken ondersteunt.

Apache Spark-componenten

Apache Spark-bibliotheken

Apache Spark bevat verschillende bibliotheken:

Spark SQL:het is een module voor het werken met gestructureerde gegevens met behulp van SQL of een DataFrame API. Het biedt een algemene manier om toegang te krijgen tot verschillende gegevensbronnen, waaronder Hive, Avro, Parquet, ORC, JSON en JDBC. U kunt zelfs gegevens uit deze bronnen samenvoegen.
Spark Streaming:het maakt het eenvoudig om schaalbare, fouttolerante streaming-applicaties te bouwen met behulp van een taalgeïntegreerde API voor streamverwerking, zodat u streamingtaken op dezelfde manier kunt schrijven als batchtaken. Het ondersteunt Java, Scala en Python. Spark Streaming herstelt zowel verloren werk als de status van de operator uit de doos, zonder enige extra code van uw kant. Hiermee kunt u dezelfde code hergebruiken voor batchverwerking, streams samenvoegen met historische gegevens of ad-hocquery's uitvoeren op streamstatus.
MLib (Machine Learning):het is een schaalbare machine learning-bibliotheek. MLlib bevat hoogwaardige algoritmen die gebruikmaken van iteratie en betere resultaten kunnen opleveren dan de one-pass benaderingen die soms op MapReduce worden gebruikt.
GraphX:het is een API voor grafieken en grafiekparallelle berekeningen. GraphX verenigt ETL, verkennende analyse en iteratieve grafiekberekening binnen één systeem. U kunt dezelfde gegevens als grafieken en collecties bekijken, grafieken efficiënt transformeren en samenvoegen met RDD's, en aangepaste iteratieve grafiekalgoritmen schrijven met behulp van de Pregel API.

Apache Spark-voordelen

Volgens de officiële documentatie zijn enkele voordelen van Apache Spark:

Snelheid:werkbelastingen 100x sneller uitvoeren. Apache Spark behaalt hoge prestaties voor zowel batch- als streaminggegevens, met behulp van een ultramoderne DAG-planner (Direct Acyclic Graph), een query-optimizer en een fysieke uitvoeringsengine.
Gebruiksgemak:schrijf applicaties snel in Java, Scala, Python, R en SQL. Spark biedt meer dan 80 operators op hoog niveau die het gemakkelijk maken om parallelle apps te bouwen. Je kunt het interactief gebruiken vanuit de Scala-, Python-, R- en SQL-shells.
Algemeen:combineer SQL, streaming en complexe analyses. Spark drijft een stapel bibliotheken aan, waaronder SQL en DataFrames, MLlib voor machine learning, GraphX en Spark Streaming. U kunt deze bibliotheken naadloos combineren in dezelfde applicatie.
Werkt overal:Spark draait op Hadoop, Apache Mesos, Kubernetes, standalone of in de cloud. Het heeft toegang tot diverse gegevensbronnen. U kunt Spark uitvoeren met de zelfstandige clustermodus, op EC2, op Hadoop YARN, op Mesos of op Kubernetes. Toegang tot gegevens in HDFS, Alluxio, Apache Cassandra, Apache HBase, Apache Hive en honderden andere gegevensbronnen.

Laten we nu eens kijken hoe we dit kunnen integreren met onze PostgreSQL-database.

Apache Spark gebruiken met PostgreSQL

We gaan ervan uit dat uw PostgreSQL-cluster actief is. Voor deze taak gebruiken we een PostgreSQL 11-server die draait op CentOS7.

Laten we eerst onze testdatabase maken op onze PostgreSQL-server:

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

Nu gaan we een tabel maken met de naam t1:

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

En voeg daar wat gegevens in:

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

Controleer de aangemaakte gegevens:

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

Om Apache Spark met onze PostgreSQL-database te verbinden, gebruiken we een JDBC-connector. Je kunt het hier downloaden.

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

Laten we nu Apache Spark installeren. Hiervoor moeten we de Spark-pakketten hier downloaden.

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

Om de Spark-shell uit te voeren, moeten we JAVA op onze server hebben geïnstalleerd:

$  yum install java

Dus nu kunnen we onze Spark Shell gebruiken:

$ ./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>

We hebben toegang tot onze Spark context Web UI die beschikbaar is in de poort 4040 op onze server:

Apache Spark-gebruikersinterface

In de Spark-shell moeten we het PostgreSQL JDBC-stuurprogramma toevoegen:

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

En voeg de JDBC-informatie toe die door Spark moet worden gebruikt:

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

Nu kunnen we SQL-query's uitvoeren. Laten we eerst query1 definiëren als SELECT * FROM t1, onze testtabel.

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

En maak het DataFrame:

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

Dus nu kunnen we een actie uitvoeren over dit 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>

We kunnen meer waarden toevoegen en het opnieuw uitvoeren om te bevestigen dat het de huidige waarden retourneert.

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)

Vonk

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

In ons voorbeeld laten we alleen zien hoe Apache Spark werkt met onze PostgreSQL-database, niet hoe het onze Big Data-informatie beheert.

Conclusie

Tegenwoordig is het vrij gebruikelijk om de uitdaging te hebben om big data in een bedrijf te beheren, en zoals we konden zien, kunnen we Apache Spark gebruiken om ermee om te gaan en gebruik te maken van alle functies die we eerder noemden. Big data is een enorme wereld, dus u kunt de officiële documentatie raadplegen voor meer informatie over het gebruik van Apache Spark en PostgreSQL en deze aanpassen aan uw vereisten.