PostgreSQL
 sql >> Datenbank >  >> RDS >> PostgreSQL

Big Data mit PostgreSQL und Apache Spark

PostgreSQL ist bekannt als die fortschrittlichste Open-Source-Datenbank und hilft Ihnen, Ihre Daten zu verwalten, egal wie groß, klein oder unterschiedlich der Datensatz ist, sodass Sie damit Ihre Big Data verwalten oder analysieren können, und natürlich gibt es sie mehrere Möglichkeiten, dies zu ermöglichen, z. B. Apache Spark. In diesem Blog werden wir sehen, was Apache Spark ist und wie wir es verwenden können, um mit unserer PostgreSQL-Datenbank zu arbeiten.

Für Big-Data-Analysen haben wir zwei verschiedene Arten von Analysen:

  • Stapelanalyse:Basierend auf den über einen bestimmten Zeitraum gesammelten Daten.
  • Echtzeit-(Stream-)Analyse:Basierend auf sofortigen Daten für ein sofortiges Ergebnis.

Was ist Apache Spark?

Apache Spark ist eine einheitliche Analyse-Engine für umfangreiche Datenverarbeitung, die sowohl Batch- als auch Echtzeitanalysen schneller und einfacher durchführen kann.

Es bietet High-Level-APIs in Java, Scala, Python und R und eine optimierte Engine, die allgemeine Ausführungsgraphen unterstützt.

Apache Spark-Komponenten

Apache Spark-Bibliotheken

Apache Spark enthält verschiedene Bibliotheken:

  • Spark SQL:Es ist ein Modul zum Arbeiten mit strukturierten Daten unter Verwendung von SQL oder einer DataFrame-API. Es bietet eine gemeinsame Möglichkeit, auf eine Vielzahl von Datenquellen zuzugreifen, darunter Hive, Avro, Parquet, ORC, JSON und JDBC. Sie können sogar Daten aus diesen Quellen zusammenführen.
  • Spark-Streaming:Es macht es einfach, skalierbare, fehlertolerante Streaming-Anwendungen mit einer sprachintegrierten API zur Stream-Verarbeitung zu erstellen, sodass Sie Streaming-Jobs genauso schreiben können wie Batch-Jobs. Es unterstützt Java, Scala und Python. Spark Streaming stellt sowohl verlorene Arbeit als auch den Operatorstatus sofort wieder her, ohne zusätzlichen Code Ihrerseits. Sie können denselben Code für die Stapelverarbeitung wiederverwenden, Streams mit historischen Daten verknüpfen oder Ad-hoc-Abfragen zum Stream-Status ausführen.
  • MLib (Machine Learning):Dies ist eine skalierbare Bibliothek für maschinelles Lernen. MLlib enthält hochwertige Algorithmen, die Iterationen nutzen und bessere Ergebnisse liefern können als die One-Pass-Näherungen, die manchmal bei MapReduce verwendet werden.
  • GraphX:Es ist eine API für Graphen und graphparallele Berechnungen. GraphX ​​vereint ETL, explorative Analyse und iterative Graphberechnung in einem einzigen System. Sie können dieselben Daten sowohl als Diagramme als auch als Sammlungen anzeigen, Diagramme mit RDDs effizient umwandeln und verbinden und mithilfe der Pregel-API benutzerdefinierte iterative Diagrammalgorithmen schreiben.

Vorteile von Apache Spark

Laut der offiziellen Dokumentation sind einige Vorteile von Apache Spark:

  • Geschwindigkeit:Führen Sie Workloads 100-mal schneller aus. Apache Spark erreicht eine hohe Leistung sowohl für Batch- als auch für Streaming-Daten, indem es einen hochmodernen DAG-Scheduler (Direct Acyclic Graph), einen Abfrageoptimierer und eine physische Ausführungs-Engine verwendet.
  • Benutzerfreundlichkeit:Schreiben Sie Anwendungen schnell in Java, Scala, Python, R und SQL. Spark bietet über 80 High-Level-Operatoren, die es einfach machen, parallele Apps zu erstellen. Sie können es interaktiv über die Scala-, Python-, R- und SQL-Shells verwenden.
  • Allgemeines:Kombinieren Sie SQL, Streaming und komplexe Analysen. Spark unterstützt einen Stapel von Bibliotheken, darunter SQL und DataFrames, MLlib für maschinelles Lernen, GraphX ​​und Spark Streaming. Sie können diese Bibliotheken nahtlos in derselben Anwendung kombinieren.
  • Läuft überall:Spark läuft auf Hadoop, Apache Mesos, Kubernetes, eigenständig oder in der Cloud. Es kann auf verschiedene Datenquellen zugreifen. Sie können Spark im Standalone-Cluster-Modus auf EC2, auf Hadoop YARN, auf Mesos oder auf Kubernetes ausführen. Greifen Sie auf Daten in HDFS, Alluxio, Apache Cassandra, Apache HBase, Apache Hive und Hunderten anderer Datenquellen zu.

Sehen wir uns nun an, wie wir dies in unsere PostgreSQL-Datenbank integrieren können.

Verwendung von Apache Spark mit PostgreSQL

Wir gehen davon aus, dass Ihr PostgreSQL-Cluster betriebsbereit ist. Für diese Aufgabe verwenden wir einen PostgreSQL 11-Server, der auf CentOS7 ausgeführt wird.

Lassen Sie uns zuerst unsere Testdatenbank auf unserem PostgreSQL-Server erstellen:

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

Jetzt erstellen wir eine Tabelle namens t1:

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

Und fügen Sie dort einige Daten ein:

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

Überprüfen Sie die erstellten Daten:

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

Um Apache Spark mit unserer PostgreSQL-Datenbank zu verbinden, verwenden wir einen JDBC-Connector. Sie können es hier herunterladen.

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

Lassen Sie uns nun Apache Spark installieren. Dazu müssen wir die Spark-Pakete von hier herunterladen.

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

Um die Spark-Shell auszuführen, muss JAVA auf unserem Server installiert sein:

$  yum install java

Jetzt können wir also unsere Spark Shell ausführen:

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

Wir können auf unsere Spark-Kontext-Webbenutzeroberfläche zugreifen, die in Port 4040 auf unserem Server verfügbar ist:

Apache Spark-Benutzeroberfläche

In der Spark-Shell müssen wir den PostgreSQL-JDBC-Treiber hinzufügen:

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

Und fügen Sie die von Spark zu verwendenden JDBC-Informationen hinzu:

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

Jetzt können wir SQL-Abfragen ausführen. Zuerst definieren wir query1 als SELECT * FROM t1, unsere Testtabelle.

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

Und erstellen Sie den DataFrame:

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

Jetzt können wir eine Aktion über diesen DataFrame ausführen:

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>

Wir können weitere Werte hinzufügen und es erneut ausführen, nur um zu bestätigen, dass es die aktuellen Werte zurückgibt.

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)

Funke

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

In unserem Beispiel zeigen wir nur, wie Apache Spark mit unserer PostgreSQL-Datenbank arbeitet, nicht, wie es unsere Big-Data-Informationen verwaltet.

Schlussfolgerung

Heutzutage ist es ziemlich üblich, Big Data in einem Unternehmen zu verwalten, und wie wir sehen konnten, können wir Apache Spark verwenden, um damit umzugehen und alle zuvor erwähnten Funktionen zu nutzen. Big Data ist eine riesige Welt, daher können Sie in der offiziellen Dokumentation nach weiteren Informationen zur Verwendung von Apache Spark und PostgreSQL suchen und diese an Ihre Anforderungen anpassen.