Esta página se ha traducido con Cloud Translation API.

Contenedor de Dataproc para Spark

Google Distributed Cloud (GDC) air-gapped proporciona un contenedor de Dataproc para Spark. Se trata de un entorno de Apache Spark para el tratamiento de datos. Para obtener más información sobre Apache Spark, consulta https://spark.apache.org/. Usa contenedores de Dataproc Container para Spark para ejecutar aplicaciones de Spark nuevas o ya creadas en un clúster de Kubernetes de Distributed Cloud con las mínimas modificaciones. Si conoces las herramientas de Spark, puedes seguir usándolas.

Define tu aplicación Spark en un archivo YAML y Distributed Cloud asignará los recursos por ti. El contenedor de Dataproc para Spark se inicia en cuestión de segundos. Los ejecutores de Spark se amplían o se cierran en función de tus necesidades.

Configura contenedores de Dataproc Container para Spark en Distributed Cloud para usar hardware especializado, como nodos de hardware especializado o GPUs.

Desplegar el servicio Dataproc Container for Spark

El administrador de la plataforma debe instalar los servicios de Marketplace para que puedas usarlos. Ponte en contacto con tu partner de Google Cloud si necesitas Dataproc Container para Spark. Para obtener más información, consulta Instalar un paquete de software de Google Cloud Marketplace.

Requisitos previos para ejecutar aplicaciones de Spark

Debes tener una cuenta de servicio en los clústeres de usuario para usar el servicio Dataproc Container for Spark. El contenedor de Dataproc para Spark crea un pod de controlador de Spark para ejecutar una aplicación de Spark. Un pod de controlador de Spark necesita una cuenta de servicio de Kubernetes en el espacio de nombres del pod con permisos para realizar las siguientes acciones:

Permiso para crear, obtener, mostrar y eliminar pods de ejecutores.
Crea un servicio sin encabezado de Kubernetes para el controlador.

Antes de ejecutar una aplicación Spark, sigue estos pasos para asegurarte de que tienes una cuenta de servicio con los permisos anteriores en el espacio de nombres foo:

Crea una cuenta de servicio para que la use un pod de controlador de Spark en el foo espacio de nombres:
```
kubectl create serviceaccount spark --kubeconfig AO_USER_KUBECONFIG --namespace=foo
```
Nota: El espacio de nombres foo corresponde al espacio de nombres del proyecto foo.
Crea un rol para conceder permisos para crear, obtener, enumerar y eliminar pods de ejecutor, y crea un servicio sin encabezado de Kubernetes para el controlador en el espacio de nombres foo:
```
kubectl create role spark-driver --kubeconfig AO_USER_KUBECONFIG --verb=* \
--resource=pods,services,configmaps,persistentvolumeclaims \
--namespace=foo
```

Crea un enlace de rol para conceder acceso al rol de cuenta de servicio en el espacio de nombres foo:

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

Ejecutar aplicaciones de ejemplo de Spark 3

La contenerización de aplicaciones Spark simplifica la ejecución de aplicaciones de big data en tus instalaciones mediante Distributed Cloud. Como operador de aplicaciones, ejecuta aplicaciones de Spark especificadas en objetos de GKE del tipo de recurso personalizado SparkApplication.

Para ejecutar y usar una aplicación Apache Spark 3 en Distributed Cloud, sigue estos pasos:

Examina la imagen spark-operator de tu proyecto para encontrar el $DATAPROC_IMAGE al que hacer referencia en tu aplicación Spark:

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/')

Por ejemplo:

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

Escribe una especificación SparkApplication y guárdala en un archivo YAML. Para obtener más información, consulta la sección Escribir una especificación de aplicación de Spark.
Envía, ejecuta y monitoriza tu aplicación Spark tal como se ha configurado en una SparkApplication especificación del clúster de GKE con el comando kubectl. Para obtener más información, consulta la sección Ejemplos de aplicaciones.
Revisa el estado de la solicitud.
Opcional: Revisa los registros de la aplicación. Para obtener más información, consulta la sección Ver los registros de una aplicación Spark 3.
Usa la aplicación Spark para recoger y mostrar el estado del controlador y los ejecutores al usuario.

Escribir una especificación de aplicación de Spark

Una especificación SparkApplication incluye los siguientes componentes:

El campo apiVersion.
El campo kind.
El campo metadata.
La sección spec.

Para obtener más información, consulta el artículo Writing a SparkApplication Spec (Escribir una especificación de SparkApplication) en GitHub: https://github.com/kubeflow/spark-operator/blob/gh-pages/docs/user-guide.md#writing-a-sparkapplication-spec

Ejemplos de aplicaciones

En esta sección se incluyen los siguientes ejemplos con sus correspondientes SparkApplication especificaciones para ejecutar aplicaciones Spark:

Spark Pi
Spark SQL
Spark MLlib
SparkR

Spark Pi

En esta sección se incluye un ejemplo para ejecutar una aplicación de Spark Pi que requiere muchos recursos de computación y que estima 𝛑 (pi) lanzando dardos a un círculo.

Sigue estos pasos para ejecutar Spark Pi:

Aplica la siguiente SparkApplicationespecificación de ejemplo en el clúster de usuarios:

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"

Verifica que el ejemplo de especificación SparkApplication se ejecuta y se completa en 1 o 2 minutos con el siguiente comando:
```
kubectl --kubeconfig AO_USER_KUBECONFIG get SparkApplication spark-pi -n foo
```

Consulta los registros del controlador para ver el resultado:

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

La salida es similar a la siguiente:

Pi is roughly 3.1407357036785184

Para obtener más información, consulta los siguientes recursos:

Para ver el código de la aplicación, consulta el artículo Estimación de Pi de la documentación de Apache Spark: https://spark.apache.org/examples.html.
Para ver un archivo YAML de ejemplo de Spark Pi, consulta Escribir una especificación de aplicación de Spark.

Spark SQL

Sigue estos pasos para ejecutar Spark SQL:

Para ejecutar una aplicación Spark SQL que seleccione el valor 1, usa la siguiente consulta:
```
select 1;
```

Aplica el siguiente SparkApplication ejemplo de especificación en el clúster de usuarios:

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"

Verifica que el ejemplo de especificación SparkApplication se ejecuta y se completa en menos de un minuto con el siguiente comando:
```
kubectl --kubeconfig AO_USER_KUBECONFIG get SparkApplication pyspark-sql-arrow -n foo
```

Spark MLlib

Sigue estos pasos para ejecutar Spark MLlib:

Usa el siguiente ejemplo de Scala para ejecutar una instancia de Spark MLlib que realice un análisis estadístico e imprima un resultado en la consola:

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")

Aplica la siguiente SparkApplicationespecificación de ejemplo en el clúster de usuarios:

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"

Verifica que el ejemplo de especificación SparkApplication se ejecuta y se completa en menos de un minuto con el siguiente comando:
```
kubectl --kubeconfig AO_USER_KUBECONFIG get SparkApplication spark-ml -n foo
```

SparkR

Sigue estos pasos para ejecutar SparkR:

Usa el siguiente código de ejemplo para ejecutar una instancia de SparkR que cargue un conjunto de datos incluido e imprima la primera línea:
```
library(SparkR)
sparkR.session()
df <- as.DataFrame(faithful)
head(df)
```

Aplica el siguiente SparkApplication ejemplo de especificación en el clúster de usuarios:

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"

Verifica que el ejemplo de especificación SparkApplication se ejecuta y se completa en menos de un minuto con el siguiente comando:
```
kubectl --kubeconfig AO_USER_KUBECONFIG get SparkApplication spark-r-dataframe -n foo
```

Ver los registros de una aplicación de Spark 3

Spark tiene los dos tipos de registros siguientes que puedes visualizar:

Registros de controladores
Registros de eventos

Usa la terminal para ejecutar comandos.

Registros del controlador

Sigue estos pasos para ver los registros de controladores de tu aplicación Spark:

Busca tu pod de controlador de Spark:
```
kubectl -n spark get pods
```
Abre los registros del pod del controlador de Spark:
```
kubectl -n spark logs DRIVER_POD
```
Sustituye DRIVER_POD por el nombre del pod del controlador de Spark que has encontrado en el paso anterior.

Registros de eventos

Puedes encontrar los registros de eventos en la ruta especificada en el archivo YAML de la especificación SparkApplication.

Sigue estos pasos para ver los registros de eventos de tu aplicación Spark:

Abre el archivo YAML de la especificación SparkApplication.
Busca el campo spec en el archivo.
Busca el campo sparkConf anidado en el campo spec.
Busca el valor del campo spark.eventLog.dir anidado en la sección sparkConf.
Abre la ruta para ver los registros de eventos.

Para ver un archivo YAML de ejemplo de la especificación SparkApplication, consulta Escribir una especificación de aplicación de Spark.

Ponte en contacto con tu gestor de cuentas para obtener más información.