Big Data med PostgreSQL og Apache Spark

PostgreSQL er velkendt som den mest avancerede opensource-database, og den hjælper dig med at administrere dine data, uanset hvor stort, lille eller anderledes datasættet er, så du kan bruge det til at administrere eller analysere dine big data, og selvfølgelig er der flere måder at gøre dette muligt på, f.eks. Apache Spark. I denne blog vil vi se, hvad Apache Spark er, og hvordan vi kan bruge det til at arbejde med vores PostgreSQL-database.

Til big data-analyse har vi to forskellige typer analyser:

Batchanalyse:Baseret på de data, der er indsamlet over en periode.
Analyse i realtid (stream):Baseret på umiddelbare data for et øjeblikkeligt resultat.

Hvad er Apache Spark?

Apache Spark er en samlet analysemotor til databehandling i stor skala, der kan arbejde på både batch- og realtidsanalyse på en hurtigere og nemmere måde.

Det giver API'er på højt niveau i Java, Scala, Python og R og en optimeret motor, der understøtter generelle udførelsesgrafer.

Apache Spark-komponenter

Apache Spark Libraries

Apache Spark inkluderer forskellige biblioteker:

Spark SQL:Det er et modul til at arbejde med strukturerede data ved hjælp af SQL eller en DataFrame API. Det giver en fælles måde at få adgang til en række datakilder, herunder Hive, Avro, Parquet, ORC, JSON og JDBC. Du kan endda samle data på tværs af disse kilder.
Spark Streaming:Det gør det nemt at bygge skalerbare fejltolerante streamingapplikationer ved hjælp af en sprogintegreret API til at streame behandling, så du kan skrive streamingjob på samme måde, som du skriver batchjobs. Det understøtter Java, Scala og Python. Spark Streaming gendanner både tabt arbejde og operatørstatus ud af boksen uden nogen ekstra kode fra din side. Det giver dig mulighed for at genbruge den samme kode til batchbehandling, forbinde strømme mod historiske data eller køre ad hoc-forespørgsler i strømtilstand.
MLib (Machine Learning):Det er et skalerbart maskinlæringsbibliotek. MLlib indeholder algoritmer af høj kvalitet, der udnytter iteration og kan give bedre resultater end de one-pass approksimationer, der nogle gange bruges på MapReduce.
GraphX:Det er et API til grafer og grafparallel beregning. GraphX forener ETL, eksplorativ analyse og iterativ grafberegning i et enkelt system. Du kan se de samme data som både grafer og samlinger, transformere og kombinere grafer med RDD'er effektivt og skrive brugerdefinerede iterative grafalgoritmer ved hjælp af Pregel API.

Apache Spark Fordele

Ifølge den officielle dokumentation er nogle fordele ved Apache Spark:

Hastighed:Kør arbejdsbelastninger 100 gange hurtigere. Apache Spark opnår høj ydeevne for både batch- og streamingdata ved hjælp af en avanceret DAG (Direct Acyclic Graph)-planlægger, en forespørgselsoptimering og en fysisk udførelsesmotor.
Anvendelse:Skriv programmer hurtigt i Java, Scala, Python, R og SQL. Spark tilbyder over 80 operatører på højt niveau, der gør det nemt at bygge parallelle apps. Du kan bruge det interaktivt fra Scala-, Python-, R- og SQL-skallene.
Generalitet:Kombiner SQL, streaming og komplekse analyser. Spark driver en stak af biblioteker inklusive SQL og DataFrames, MLlib til maskinlæring, GraphX og Spark Streaming. Du kan kombinere disse biblioteker problemfrit i den samme applikation.
Kører overalt:Spark kører på Hadoop, Apache Mesos, Kubernetes, selvstændigt eller i skyen. Det kan få adgang til forskellige datakilder. Du kan køre Spark ved hjælp af dens selvstændige klyngetilstand på EC2, på Hadoop YARN, på Mesos eller på Kubernetes. Få adgang til data i HDFS, Alluxio, Apache Cassandra, Apache HBase, Apache Hive og hundredvis af andre datakilder.

Lad os nu se, hvordan vi kan integrere dette med vores PostgreSQL-database.

Sådan bruges Apache Spark med PostgreSQL

Vi antager, at du har din PostgreSQL-klynge oppe at køre. Til denne opgave bruger vi en PostgreSQL 11-server, der kører på CentOS7.

Lad os først oprette vores testdatabase på vores PostgreSQL-server:

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

Nu skal vi lave en tabel kaldet t1:

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

Og indsæt nogle data der:

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

Tjek de oprettede data:

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

For at forbinde Apache Spark til vores PostgreSQL-database bruger vi en JDBC-connector. Du kan downloade den herfra.

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

Lad os nu installere Apache Spark. Til dette skal vi downloade spark-pakkerne herfra.

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

For at køre Spark-skallen skal vi have JAVA installeret på vores server:

$  yum install java

Så nu kan vi køre vores 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>

Vi kan få adgang til vores Spark context Web UI tilgængelig i port 4040 på vores server:

Apache Spark UI

Ind i Spark-skallen skal vi tilføje PostgreSQL JDBC-driveren:

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

Og tilføj JDBC-oplysningerne, der skal bruges af 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

Nu kan vi udføre SQL-forespørgsler. Lad os først definere query1 som SELECT * FROM t1, vores testtabel.

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

Og opret DataFrame:

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

Så nu kan vi udføre en handling over denne 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>

Vi kan tilføje flere værdier og køre det igen bare for at bekræfte, at det returnerer de aktuelle værdier.

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)

Gnist

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

I vores eksempel viser vi kun, hvordan Apache Spark fungerer med vores PostgreSQL-database, ikke hvordan den administrerer vores Big Data-oplysninger.

Konklusion

I dag er det ret almindeligt at have udfordringen med at administrere big data i en virksomhed, og som vi kunne se, kan vi bruge Apache Spark til at klare det og gøre brug af alle de funktioner, som vi nævnte tidligere. Big data er en enorm verden, så du kan tjekke den officielle dokumentation for mere information om brugen af Apache Spark og PostgreSQL og tilpasse det til dine krav.