Diese Seite wurde von der Cloud Translation API übersetzt.

Dataproc-Container für Spark

Google Distributed Cloud (GDC) Air-Gap bietet einen Dataproc-Container für Spark. Das ist eine Apache Spark-Umgebung für die Datenverarbeitung. Weitere Informationen zu Apache Spark finden Sie unter https://spark.apache.org/. Mit Containern von Dataproc Container for Spark können Sie neue oder vorhandene Spark-Anwendungen in einem Distributed Cloud Kubernetes-Cluster mit minimalen Änderungen ausführen. Wenn Sie mit Spark-Tools vertraut sind, können Sie sie weiterhin verwenden.

Definieren Sie Ihre Spark-Anwendung in einer YAML-Datei. Distributed Cloud weist die Ressourcen für Sie zu. Der Dataproc-Container für Spark wird in Sekundenschnelle gestartet. Spark-Executors werden je nach Bedarf hoch- oder heruntergefahren.

Konfigurieren Sie Container aus Dataproc Container for Spark on Distributed Cloud so, dass sie spezielle Hardware wie spezielle Hardwareknoten oder GPUs verwenden.

Dataproc Container for Spark-Dienst bereitstellen

Der Plattformadministrator muss Marketplace-Dienste für Sie installieren, bevor Sie sie verwenden können. Wenden Sie sich an Ihren PA, wenn Sie Dataproc Container für Spark benötigen. Weitere Informationen finden Sie unter GDC Marketplace-Softwarepaket installieren.

Voraussetzungen für das Ausführen von Spark-Anwendungen

Sie benötigen ein Dienstkonto in Nutzerclustern, um den Dienst „Dataproc Container for Spark“ zu verwenden. Mit dem Dataproc-Container für Spark wird ein Spark-Treiber-Pod erstellt, um eine Spark-Anwendung auszuführen. Ein Spark-Treiber-Pod benötigt ein Kubernetes-Dienstkonto im Namespace des Pods mit Berechtigungen für die folgenden Aktionen:

Executor-Pods erstellen, abrufen, auflisten und löschen.
Erstellen Sie einen monitorlosen Kubernetes-Dienst für den Treiber.

Bevor Sie eine Spark-Anwendung ausführen, führen Sie die folgenden Schritte aus, um sicherzustellen, dass Sie ein Dienstkonto mit den oben genannten Berechtigungen im foo-Namespace haben:

Erstellen Sie ein Dienstkonto für einen Spark-Treiber-Pod, der im Namespace foo verwendet werden soll:
```
kubectl create serviceaccount spark --kubeconfig AO_USER_KUBECONFIG --namespace=foo
```
Hinweis: Der Namespace foo entspricht dem Namespace des Projekts foo.
Erstellen Sie eine Rolle zum Erteilen von Berechtigungen zum Erstellen, Abrufen, Auflisten und Löschen von Executor-Pods und erstellen Sie einen monitorlosen Kubernetes-Dienst für den Treiber im Namespace foo:
```
kubectl create role spark-driver --kubeconfig AO_USER_KUBECONFIG --verb=* \
--resource=pods,services,configmaps,persistentvolumeclaims \
--namespace=foo
```

Erstellen Sie eine Rollenbindung, um dem Dienstkonto Rollenzugriff im Namespace foo zu gewähren:

kubectl create --kubeconfig AO_USER_KUBECONFIG \
rolebinding spark-spark-driver \
--role=spark-driver --serviceaccount=foo:spark \
--namespace=foo

Spark 3-Beispielanwendungen ausführen

Durch das Containerisieren von Spark-Anwendungen wird die Ausführung von Big-Data-Anwendungen vor Ort mit Distributed Cloud vereinfacht. Als Application Operator (AO) können Sie Spark-Anwendungen ausführen, die in GKE-Objekten des benutzerdefinierten Ressourcentyps SparkApplication angegeben sind.

Führen Sie die folgenden Schritte aus, um eine Apache Spark 3-Anwendung in Distributed Cloud auszuführen und zu verwenden:

Sehen Sie sich das spark-operator-Bild in Ihrem Projekt an, um die $DATAPROC_IMAGE zu finden, auf die Sie in Ihrer Spark-Anwendung verweisen können:

export DATAPROC_IMAGE=$(kubectl get pod --kubeconfig AO_USER_KUBECONFIG \
--selector app.kubernetes.io/name=spark-operator -n foo \
-o=jsonpath='{.items[*].spec.containers[0].image}' \
| sed 's/spark-operator/dataproc/')

Beispiel:

export DATAPROC_IMAGE=10.200.8.2:10443/dataproc-service/private-cloud-devel/dataproc:3.1-dataproc-17

Schreiben Sie eine SparkApplication-Spezifikation und speichern Sie sie in einer YAML-Datei. Weitere Informationen finden Sie im Abschnitt Spark-Anwendungsspezifikation schreiben.
Senden, ausführen und überwachen Sie Ihre Spark-Anwendung, wie in einer SparkApplication-Spezifikation konfiguriert, im GKE-Cluster mit dem Befehl kubectl. Weitere Informationen finden Sie im Abschnitt Anwendungsbeispiele.
Prüfen Sie den Status der Anwendung.
Optional: Überprüfen Sie die Anwendungslogs. Weitere Informationen finden Sie im Abschnitt Logs einer Spark 3-Anwendung ansehen.
Verwenden Sie die Spark-Anwendung, um den Status des Treibers und der Executors zu erfassen und dem Nutzer anzuzeigen.

Spezifikation für Spark-Anwendung schreiben

Eine SparkApplication-Spezifikation enthält die folgenden Komponenten:

Das Feld apiVersion.
Das Feld kind.
Das Feld metadata.
Der Abschnitt spec.

Weitere Informationen finden Sie im Leitfaden zum Schreiben einer SparkApplication-Spezifikation auf GitHub: https://github.com/kubeflow/spark-operator/blob/gh-pages/docs/user-guide.md#writing-a-sparkapplication-spec

Anwendungsbeispiele

Dieser Abschnitt enthält die folgenden Beispiele mit den entsprechenden SparkApplication-Spezifikationen zum Ausführen von Spark-Anwendungen:

Spark Pi
Spark SQL
Spark MLlib
SparkR

Spark Pi

Dieser Abschnitt enthält ein Beispiel für die Ausführung einer rechenintensiven Spark Pi-Anwendung, die 𝛑 (Pi) schätzt, indem sie Darts in einen Kreis wirft.

Führen Sie die folgenden Schritte aus, um Spark Pi auszuführen:

Wenden Sie das folgende Beispiel für die SparkApplication-Spezifikation im Nutzercluster an:

apiVersion: "sparkoperator.k8s.io/v1beta2"
kind: SparkApplication
metadata:
  name: spark-pi
  namespace: foo
spec:
  type: Python
  pythonVersion: "3"
  mode: cluster
  image: "${DATAPROC_IMAGE?}"
  imagePullPolicy: IfNotPresent
  mainApplicationFile: "local:///usr/lib/spark/examples/src/main/python/pi.py"
  sparkVersion: "3.1.3"
  restartPolicy:
    type: Never
  driver:
    cores: 1
    coreLimit: "1000m"
    memory: "512m"
    serviceAccount: spark
  executor:
    cores: 1
    instances: 1
    memory: "512m"

Prüfen Sie mit dem folgenden Befehl, ob das SparkApplication-Spezifikationsbeispiel ausgeführt wird und innerhalb von 1 bis 2 Minuten abgeschlossen ist:
```
kubectl --kubeconfig AO_USER_KUBECONFIG get SparkApplication spark-pi -n foo
```

Sehen Sie sich die Treiberlogs an, um das Ergebnis zu sehen:

kubectl --kubeconfig AO_USER_KUBECONFIG logs spark-pi-driver -n foo | grep "Pi is roughly"

Die Ausgabe sieht in etwa so aus:

Pi is roughly 3.1407357036785184

Weitere Informationen finden Sie in den folgenden Ressourcen:

Den Anwendungscode finden Sie in der Apache Spark-Dokumentation im Artikel Pi estimation (Pi-Schätzung): https://spark.apache.org/examples.html.
Eine Beispiel-YAML-Datei für Spark Pi finden Sie unter Spark-Anwendungsspezifikation schreiben.

Spark SQL

Führen Sie die folgenden Schritte aus, um Spark SQL auszuführen:

Verwenden Sie die folgende Abfrage, um eine Spark SQL-Anwendung auszuführen, die den Wert 1 auswählt:
```
select 1;
```

Wenden Sie das folgende SparkApplication-Spezifikationsbeispiel im Nutzercluster an:

apiVersion: "sparkoperator.k8s.io/v1beta2"
kind: SparkApplication
metadata:
  name: pyspark-sql-arrow
  namespace: foo
spec:
  type: Python
  mode: cluster
  image: "${DATAPROC_IMAGE?}"
  imagePullPolicy: IfNotPresent
  mainApplicationFile: "local:///usr/lib/spark/examples/src/main/python/sql/arrow.py"
  sparkVersion: "3.1.3"
  restartPolicy:
    type: Never
  driver:
    cores: 1
    coreLimit: "1000m"
    memory: "512m"
    serviceAccount: spark
  executor:
    cores: 1
    instances: 1
    memory: "512m"

Prüfen Sie mit dem folgenden Befehl, ob das SparkApplication-Spezifikationsbeispiel ausgeführt wird und in weniger als einer Minute abgeschlossen ist:
```
kubectl --kubeconfig AO_USER_KUBECONFIG get SparkApplication pyspark-sql-arrow -n foo
```

Spark MLlib

Führen Sie die folgenden Schritte aus, um Spark MLlib auszuführen:

Mit dem folgenden Scala-Beispiel können Sie eine Spark MLlib-Instanz ausführen, die eine statistische Analyse durchführt und ein Ergebnis in der Konsole ausgibt:

import org.apache.spark.ml.linalg.{Matrix, Vectors}
import org.apache.spark.ml.stat.Correlation
import org.apache.spark.sql.Row

val data = Seq(
  Vectors.sparse(4, Seq((0, 1.0), (3, -2.0))),
  Vectors.dense(4.0, 5.0, 0.0, 3.0),
  Vectors.dense(6.0, 7.0, 0.0, 8.0),
  Vectors.sparse(4, Seq((0, 9.0), (3, 1.0)))
)

val df = data.map(Tuple1.apply).toDF("features")
val Row(coeff1: Matrix) = Correlation.corr(df, "features").head
println(s"Pearson correlation matrix:\n $coeff1")

val Row(coeff2: Matrix) = Correlation.corr(df, "features", "spearman").head
println(s"Spearman correlation matrix:\n $coeff2")

Wenden Sie das folgende Beispiel für die SparkApplication-Spezifikation im Nutzercluster an:

apiVersion: "sparkoperator.k8s.io/v1beta2"
kind: SparkApplication
metadata:
  name: spark-ml
  namespace: foo
spec:
  type: Scala
  mode: cluster
  image: "${DATAPROC_IMAGE?}"
  imagePullPolicy: IfNotPresent
  mainClass: org.apache.spark.examples.ml.SummarizerExample
  mainApplicationFile: "local:///usr/lib/spark/examples/jars/spark-examples_2.12-3.1.3.jar"
  sparkVersion: "3.1.3"
  restartPolicy:
    type: Never
  driver:
    cores: 1
    coreLimit: "1000m"
    memory: "512m"
    serviceAccount: spark
  executor:
    cores: 1
    instances: 1
    memory: "512m"

Prüfen Sie mit dem folgenden Befehl, ob das SparkApplication-Spezifikationsbeispiel ausgeführt wird und in weniger als einer Minute abgeschlossen ist:
```
kubectl --kubeconfig AO_USER_KUBECONFIG get SparkApplication spark-ml -n foo
```

SparkR

Führen Sie die folgenden Schritte aus, um SparkR auszuführen:

Verwenden Sie den folgenden Beispielcode, um eine SparkR-Instanz auszuführen, die ein gebündeltes Dataset lädt und die erste Zeile ausgibt:
```
library(SparkR)
sparkR.session()
df <- as.DataFrame(faithful)
head(df)
```

Wenden Sie das folgende SparkApplication-Spezifikationsbeispiel im Nutzercluster an:

apiVersion: "sparkoperator.k8s.io/v1beta2"
kind: SparkApplication
metadata:
  name: spark-r-dataframe
  namespace: foo
spec:
  type: R
  mode: cluster
  image: "${DATAPROC_IMAGE?}"
  imagePullPolicy: Always
  mainApplicationFile: "local:///usr/lib/spark/examples/src/main/r/dataframe.R"
  sparkVersion: "3.1.3"
  restartPolicy:
    type: Never
  driver:
    cores: 1
    coreLimit: "1000m"
    memory: "512m"
    serviceAccount: spark
  executor:
    cores: 1
    instances: 1
    memory: "512m"

Prüfen Sie mit dem folgenden Befehl, ob das SparkApplication-Spezifikationsbeispiel ausgeführt wird und in weniger als einer Minute abgeschlossen ist:
```
kubectl --kubeconfig AO_USER_KUBECONFIG get SparkApplication spark-r-dataframe -n foo
```

Logs einer Spark 3-Anwendung ansehen

Spark bietet die folgenden zwei Logtypen, die Sie visualisieren können:

Treiber-Logs
Ereignisprotokolle

Verwenden Sie das Terminal, um Befehle auszuführen.

Fahrerprotokolle

Führen Sie die folgenden Schritte aus, um die Treiberlogs Ihrer Spark-Anwendung aufzurufen:

Suchen Sie den Spark-Treiber-Pod:
```
kubectl -n spark get pods
```
Öffnen Sie die Logs des Spark-Treiber-Pods:
```
kubectl -n spark logs DRIVER_POD
```
Ersetzen Sie DRIVER_POD durch den Namen des Spark-Treiber-Pods, den Sie im vorherigen Schritt ermittelt haben.

Ereignisprotokolle

Ereignisprotokolle finden Sie unter dem Pfad, der in der YAML-Datei der SparkApplication-Spezifikation angegeben ist.

Führen Sie die folgenden Schritte aus, um die Ereignisprotokolle Ihrer Spark-Anwendung aufzurufen:

Öffnen Sie die YAML-Datei der SparkApplication-Spezifikation.
Suchen Sie in der Datei das Feld spec.
Suchen Sie im Feld spec nach dem Feld sparkConf.
Suchen Sie nach dem Wert des Felds spark.eventLog.dir, das im Abschnitt sparkConf enthalten ist.
Öffnen Sie den Pfad, um Ereignisprotokolle anzusehen.

Eine Beispiel-YAML-Datei für die SparkApplication-Spezifikation finden Sie unter Spezifikation für eine Spark-Anwendung schreiben.

Weitere Informationen erhalten Sie von Ihrem Account Manager.