Managed Service para Apache Spark sin servidores ejecuta cargas de trabajo dentro de contenedores de Docker. El contenedor proporciona el entorno de ejecución para los procesos del controlador y del ejecutor de la carga de trabajo. De forma predeterminada, Managed Service para Apache Spark usa una imagen de contenedor que incluye los paquetes predeterminados de Spark, Java, Python y R asociados con una versión de actualización del entorno de ejecución. La API de lotes de Managed Service para Apache Spark te permite usar una imagen de contenedor personalizada en lugar de la imagen predeterminada. Por lo general, una imagen de contenedor personalizada agrega dependencias de Java o Python de la carga de trabajo de Spark que no proporciona la imagen de contenedor predeterminada. Importante: No incluyas Spark en tu imagen de contenedor personalizada. Managed Service para Apache Spark activará Spark en el contenedor en el entorno de ejecución.
Envía una carga de trabajo por lotes de Spark con una imagen de contenedor personalizada
gcloud
Usa el comando
gcloud dataproc batches submit spark
con la marca --container-image para especificar la imagen de contenedor personalizada
cuando envíes una carga de trabajo por lotes de Spark.
gcloud dataproc batches submit spark \ --container-image=custom-image, for example, "gcr.io/my-project-id/my-image:1.0.1" \ --region=region \ --jars=path to user workload jar located in Cloud Storage or included in the custom container \ --class=The fully qualified name of a class in the jar file, such as org.apache.spark.examples.SparkPi \ -- add any workload arguments here
Notas:
- Imagen personalizada: Especifica la imagen de contenedor personalizada con el
siguiente formato de nombre de imagen de Container Registry:
{hostname}/{project-id}/{image}:{tag}, por ejemplo, "gcr.io/my-project-id/my-image:1.0.1". Nota: Debes alojar tu imagen de contenedor personalizada en Container Registry o Artifact Registry (GAR). (Managed Service para Apache Spark no puede recuperar contenedores de otros registros). --jars: Especifica una ruta de acceso a una carga de trabajo del usuario incluida en tu imagen de contenedor personalizada o ubicada en Cloud Storage, por ejemplo,file:///opt/spark/jars/spark-examples.jarogs://my-bucket/spark/jars/spark-examples.jar.- Otras opciones de comando de lotes: Puedes agregar otras marcas de comando de lotes opcionales, por ejemplo, para usar un servidor de historial persistente (PHS). Nota: El PHS debe estar ubicado en la región en la que ejecutas las cargas de trabajo por lotes.
- Argumentos de la carga de trabajo: Puedes agregar cualquier argumento de la carga de trabajo si agregas "--" al final del comando, seguido de los argumentos de la carga de trabajo.
REST
La imagen de contenedor personalizada se proporciona a través del campo RuntimeConfig.containerImage como parte de una solicitud a la API batches.create.
En el siguiente ejemplo, se muestra cómo usar un contenedor personalizado para enviar una carga de trabajo por lotes con la API de batches.create de Managed Service para Apache Spark.
Antes de usar cualquiera de los datos de solicitud a continuación, realiza los siguientes reemplazos:
- project-id: ID del proyecto de Google Cloud
- region: región
- custom-container-image: Especifica la imagen de contenedor personalizada con el
siguiente formato de nombre de imagen de Container Registry:
{hostname}/{project-id}/{image}:{tag}, por ejemplo, "gcr.io/my-project-id/my-image:1.0.1". Nota: Debes alojar tu contenedor personalizado en Container Registry o Artifact Registry . (Managed Service para Apache Spark no puede recuperar contenedores de otros registros). jar-uri: Especifica una ruta de acceso a un archivo JAR de carga de trabajo incluido en tu imagen de contenedor personalizada o ubicado en Cloud Storage, por ejemplo, "/opt/spark/jars/spark-examples.jar" o "gs:///spark/jars/spark-examples.jar".class: Es el nombre completamente calificado de una clase en el archivo JAR, como "org.apache.spark.examples.SparkPi".- Otras opciones: Puedes usar otros campos de recursos de carga de trabajo por lotes, por ejemplo,
usar el campo
sparkBatch.argspara pasar argumentos a tu carga de trabajo (consulta la documentación del recursoBatchpara obtener más información). Para usar un servidor de historial persistente (PHS), consulta Configura un servidor de historial persistente. Nota: El PHS debe estar ubicado en la región en la que ejecutas las cargas de trabajo por lotes.
Método HTTP y URL:
POST https://dataproc.googleapis.com/v1/projects/project-id/locations/region/batches
Cuerpo JSON de la solicitud:
{
"runtimeConfig":{
"containerImage":"custom-container-image
},
"sparkBatch":{
"jarFileUris":[
"jar-uri"
],
"mainClass":"class"
}
}
Para enviar tu solicitud, expande una de estas opciones:
Deberías recibir una respuesta JSON similar a la que se muestra a continuación:
{
"name":"projects/project-id/locations/region/batches/batch-id",
"uuid":",uuid",
"createTime":"2021-07-22T17:03:46.393957Z",
"runtimeConfig":{
"containerImage":"gcr.io/my-project/my-image:1.0.1"
},
"sparkBatch":{
"mainClass":"org.apache.spark.examples.SparkPi",
"jarFileUris":[
"/opt/spark/jars/spark-examples.jar"
]
},
"runtimeInfo":{
"outputUri":"gs://dataproc-.../driveroutput"
},
"state":"SUCCEEDED",
"stateTime":"2021-07-22T17:06:30.301789Z",
"creator":"account-email-address",
"runtimeConfig":{
"properties":{
"spark:spark.executor.instances":"2",
"spark:spark.driver.cores":"2",
"spark:spark.executor.cores":"2",
"spark:spark.app.name":"projects/project-id/locations/region/batches/batch-id"
}
},
"environmentConfig":{
"peripheralsConfig":{
"sparkHistoryServerConfig":{
}
}
},
"operation":"projects/project-id/regions/region/operation-id"
}
Compila una imagen de contenedor personalizada
Las imágenes de contenedor personalizadas de Managed Service para Apache Spark son imágenes de Docker. Puedes usar las herramientas para compilar imágenes de Docker y crear imágenes de contenedor personalizadas, pero hay condiciones que las imágenes deben cumplir para ser compatibles con Managed Service para Apache Spark. En las siguientes secciones, se explican estas condiciones.
Sistema operativo
Puedes elegir cualquier imagen base del sistema operativo para tu imagen de contenedor personalizada.
Recomendación: Usa las imágenes predeterminadas de Debian 12, por ejemplo, debian:12-slim,
ya que se probaron para evitar problemas de compatibilidad.
Utilidades
Debes incluir los siguientes paquetes de utilidades, que son necesarios para ejecutar Spark, en tu imagen de contenedor personalizada:
procpstini
Para ejecutar XGBoost desde Spark (Java o Scala), debes incluir libgomp1
Usuario de contenedor
Managed Service para Apache Spark ejecuta contenedores como el usuario de Linux spark con un
UID de 1099 y un GID de 1099. Las directivas USER establecidas en los Dockerfiles de imágenes de contenedor personalizadas se ignoran en el entorno de ejecución. Usa el UID y el GID para los permisos del sistema de archivos. Por ejemplo, si agregas un archivo JAR en /opt/spark/jars/my-lib.jar
en la imagen como una dependencia de carga de trabajo, debes otorgar al usuario spark permiso de lectura
al archivo.
Transmisión de imágenes
Managed Service para Apache Spark suele comenzar una carga de trabajo que requiere una imagen de contenedor personalizada descargando toda la imagen en el disco. Esto puede significar un retraso en el tiempo de inicialización, en especial para los clientes con imágenes grandes.
En su lugar, puedes usar la transmisión de imágenes, que es un método para extraer datos de imágenes según sea necesario. Esto permite que la carga de trabajo se inicie sin esperar a que se descargue toda la imagen, lo que puede mejorar el tiempo de inicialización. Para habilitar la transmisión de imágenes, debes habilitar la API del sistema de archivos de contenedor. También debes almacenar tus imágenes de contenedor en Artifact Registry, y el repositorio de Artifact Registry debe estar en la misma región que tu carga de trabajo de Managed Service para Apache Spark o en una multirregión que corresponda a la región en la que se ejecuta tu carga de trabajo. Si Managed Service para Apache Spark no admite la imagen o el servicio de transmisión de imágenes no está disponible, nuestra implementación de transmisión descarga la imagen completa.
Ten en cuenta que no admitimos lo siguiente para la transmisión de imágenes:
- Imágenes con capas vacías o duplicadas
- Imágenes que usan el manifiesto de imágenes de V2, versión de esquema 1
En estos casos, Managed Service para Apache Spark extrae la imagen completa antes de iniciar la carga de trabajo.
Requisitos adicionales
Si los Controles del servicio de VPC protegen las imágenes de contenedor y usas la transmisión de imágenes, también debes incluir la API de transmisión de imágenes (
containerfilesystem.googleapis.com) en el perímetro de servicio.Si la carga de trabajo de Spark no usa la cuenta de servicio predeterminada, debes asegurarte de que tu cuenta de servicio personalizada tenga el rol de IAM de Consumidor de Service Usage (
roles/serviceusage.serviceUsageConsumer) en el proyecto que aloja la imagen de contenedor.
Spark
No incluyas Spark en la imagen de contenedor personalizada. En el entorno de ejecución,
Managed Service para Apache Spark activa los objetos binarios y las configuraciones de Spark desde el host
en el contenedor: los objetos binarios se activan en el directorio /usr/lib/spark y
las configuraciones se activan en el directorio /etc/spark/conf. Managed Service para Apache Spark anula los archivos existentes en estos
directorios durante el tiempo de ejecución.
Java Runtime Environment
No incluyas tu propio Java Runtime Environment (JRE) en la imagen de contenedor
personalizada. En el entorno de ejecución, Managed Service para Apache Spark activa OpenJDK desde el host
en el contenedor. Si incluyes un JRE en tu imagen de contenedor personalizada, se
ignorará.
Paquetes Java
Puedes incluir archivos jar como dependencias de la carga de trabajo de Spark en tu imagen de contenedor
personalizada y puedes configurar la variable de entorno SPARK_EXTRA_CLASSPATH para
incluir los archivos jar. Managed Service para Apache Spark agregará el valor de la variable de entorno
en la ruta de clase de los procesos de JVM de Spark. Recomendación: Coloca los archivos JAR en el directorio /opt/spark/jars y establece SPARK_EXTRA_CLASSPATH en /opt/spark/jars/*.
Puedes incluir el archivo JAR de la carga de trabajo en tu imagen de contenedor personalizada y, luego, hacer referencia
a él con una ruta de acceso local cuando envíes la carga de trabajo, por ejemplo,
file:///opt/spark/jars/my-spark-job.jar (consulta Envía una carga de trabajo por lotes de Spark
con una imagen de contenedor personalizada para ver un ejemplo).
Paquetes de Python
De forma predeterminada, Managed Service para Apache Spark activa una compilación de entorno de Conda con
un repositorio de Conda-Forge de OSS desde el host hasta el
directorio /opt/managed-spark/conda en el contenedor durante el tiempo de ejecución.
PYSPARK_PYTHON se establece como /opt/managed-spark/conda/bin/python. Su directorio base, /opt/managed-spark/conda/bin, se incluye en PATH.
Puedes incluir tu entorno de Python con paquetes en un directorio diferente
en tu imagen de contenedor personalizada, por ejemplo, en /opt/conda, y establecer la
variable de entorno PYSPARK_PYTHON en /opt/conda/bin/python.
Tu imagen de contenedor personalizada puede incluir otros módulos de Python que no formen parte
del entorno de Python, por ejemplo, secuencias de comandos de Python con funciones de utilidad.
Configura la variable de entorno PYTHONPATH para que incluya los directorios en los que se
encuentran los módulos.
Entorno de R
Puedes personalizar el entorno de R en tu imagen de contenedor personalizada con una de las siguientes opciones:
- Usa Conda para administrar e instalar paquetes de R desde el canal
conda-forge. - Agrega un repositorio de R para el SO Linux de tu imagen de contenedor y, luego, instala los paquetes de R con el administrador de paquetes del SO Linux (consulta el índice de paquetes de software de R).
Cuando uses cualquiera de las opciones, debes configurar la variable de entorno R_HOME para
que apunte a tu entorno de R personalizado. Excepción: Si usas Conda para administrar tu entorno de R y personalizar tu entorno de Python, no necesitas configurar la variable de entorno R_HOME, ya que se configura automáticamente en función de la variable de entorno PYSPARK_PYTHON.
Ejemplo de compilación de imagen de contenedor personalizada
En esta sección, se incluyen ejemplos de compilación de imágenes de contenedor personalizadas, que incluyen Dockerfiles de muestra, seguidos de comandos de compilación. Una muestra incluye la configuración mínima necesaria para compilar una imagen. La otra muestra incluye ejemplos de configuración adicional, incluidas las bibliotecas de Python y R.
Recomendación de coubicación de arquitectura
Para garantizar la inicialización rápida de contenedores con la transmisión de imágenes de Google Cloud (API de sistema de archivos de contenedor) y evitar las tarifas de movimiento de datos entre regiones, los siguientes servicios deben ubicarse en la misma región:
- Artifact Registry
- Bucket de Cloud Storage
- Carga de trabajo por lotes de Managed Service para Apache Spark
Paso 1: Configuración del entorno
Abre la terminal o Google Cloud Shell y configura las siguientes variables de entorno para simplificar el proceso de implementación.
export PROJECT_ID="YOUR_PROJECT_ID"
export REGION="us-east1"
export REPO_NAME="spark-images"
export BUCKET_NAME="spark-jobs-bucket-${PROJECT_ID}-${REGION}"
Paso 2: Configuración del Dockerfile
Configuración mínima
# Recommendation: Use Debian 12.
FROM debian:12-slim
# Suppress interactive prompts.
ENV DEBIAN_FRONTEND=noninteractive
# Install utilities required by Spark scripts.
RUN apt update && apt install -y procps tini libjemalloc2
# Enable jemalloc as default memory allocator.
ENV LD_PRELOAD=/usr/lib/x86_64-linux-gnu/libjemalloc.so.2
# Create the 'spark' group/user.
# The GID and UID must be 1099. Home directory is required.
RUN groupadd -g 1099 spark
RUN useradd -u 1099 -g 1099 -d /home/spark -m spark
USER spark
Configuración adicional
# Recommendation: Use Debian 12.
FROM debian:12-slim
# Suppress interactive prompts.
ENV DEBIAN_FRONTEND=noninteractive
# Install utilities required by Spark scripts.
RUN apt update && apt install -y procps tini libjemalloc2
# Enable jemalloc as default memory allocator
ENV LD_PRELOAD=/usr/lib/x86_64-linux-gnu/libjemalloc.so.2
# Install utilities required by XGBoost for Spark.
RUN apt install -y procps libgomp1
# Install and configure Miniconda3.
ENV CONDA_HOME=/opt/miniforge3
ENV PYSPARK_PYTHON=${CONDA_HOME}/bin/python
ENV PATH=${CONDA_HOME}/bin:${PATH}
ADD https://github.com/conda-forge/miniforge/releases/latest/download/Miniforge3-Linux-x86_64.sh .
RUN bash Miniforge3-Linux-x86_64.sh -b -p /opt/miniforge3 \
&& ${CONDA_HOME}/bin/conda config --system --set always_yes True \
&& ${CONDA_HOME}/bin/conda config --system --set auto_update_conda False \
&& ${CONDA_HOME}/bin/conda config --system --set channel_priority strict
# Packages ipython and ipykernel are required if using custom conda and want to
# use this container for running notebooks.
RUN ${CONDA_HOME}/bin/mamba install ipython ipykernel jupyter
# Install Google Cloud SDK.
RUN ${CONDA_HOME}/bin/mamba install -n base google-cloud-sdk
# Install Conda packages.
#
# The following packages are installed in the default image.
# Recommendation: include all packages.
#
# Use mamba to quickly install packages.
RUN ${CONDA_HOME}/bin/mamba install -n base \
accelerate \
bigframes \
cython \
deepspeed \
evaluate \
fastavro \
fastparquet \
gcsfs \
google-cloud-aiplatform \
google-cloud-bigquery-storage \
google-cloud-bigquery[pandas] \
google-cloud-bigtable \
google-cloud-container \
google-cloud-datacatalog \
google-cloud-dataproc \
google-cloud-datastore \
google-cloud-language \
google-cloud-logging \
google-cloud-monitoring \
google-cloud-pubsub \
google-cloud-redis \
google-cloud-spanner \
google-cloud-speech \
google-cloud-storage \
google-cloud-texttospeech \
google-cloud-translate \
google-cloud-vision \
langchain \
lightgbm \
koalas \
matplotlib \
mlflow \
nltk \
numba \
numpy \
openblas \
orc \
pandas \
pyarrow \
pynvml \
pysal \
pytables \
python \
pytorch-cpu \
regex \
requests \
rtree \
scikit-image \
scikit-learn \
scipy \
seaborn \
sentence-transformers \
sqlalchemy \
sympy \
tokenizers \
transformers \
virtualenv \
xgboost
# Install pip packages.
RUN ${PYSPARK_PYTHON} -m pip install \
spark-tensorflow-distributor \
torcheval
# Install R and R libraries.
RUN ${CONDA_HOME}/bin/mamba install -n base \
r-askpass \
r-assertthat \
r-backports \
r-bit \
r-bit64 \
r-blob \
r-boot \
r-brew \
r-broom \
r-callr \
r-caret \
r-cellranger \
r-chron \
r-class \
r-cli \
r-clipr \
r-cluster \
r-codetools \
r-colorspace \
r-commonmark \
r-cpp11 \
r-crayon \
r-curl \
r-data.table \
r-dbi \
r-dbplyr \
r-desc \
r-devtools \
r-digest \
r-dplyr \
r-ellipsis \
r-evaluate \
r-fansi \
r-fastmap \
r-forcats \
r-foreach \
r-foreign \
r-fs \
r-future \
r-generics \
r-ggplot2 \
r-gh \
r-glmnet \
r-globals \
r-glue \
r-gower \
r-gtable \
r-haven \
r-highr \
r-hms \
r-htmltools \
r-htmlwidgets \
r-httpuv \
r-httr \
r-hwriter \
r-ini \
r-ipred \
r-isoband \
r-iterators \
r-jsonlite \
r-kernsmooth \
r-knitr \
r-labeling \
r-later \
r-lattice \
r-lava \
r-lifecycle \
r-listenv \
r-lubridate \
r-magrittr \
r-markdown \
r-mass \
r-matrix \
r-memoise \
r-mgcv \
r-mime \
r-modelmetrics \
r-modelr \
r-munsell \
r-nlme \
r-nnet \
r-numderiv \
r-openssl \
r-pillar \
r-pkgbuild \
r-pkgconfig \
r-pkgload \
r-plogr \
r-plyr \
r-praise \
r-prettyunits \
r-processx \
r-prodlim \
r-progress \
r-promises \
r-proto \
r-ps \
r-purrr \
r-r6 \
r-randomforest \
r-rappdirs \
r-rcmdcheck \
r-rcolorbrewer \
r-rcpp \
r-rcurl \
r-readr \
r-readxl \
r-recipes \
r-recommended \
r-rematch \
r-remotes \
r-reprex \
r-reshape2 \
r-rlang \
r-rmarkdown \
r-rodbc \
r-roxygen2 \
r-rpart \
r-rprojroot \
r-rserve \
r-rsqlite \
r-rstudioapi \
r-rvest \
r-scales \
r-selectr \
r-sessioninfo \
r-shape \
r-shiny \
r-sourcetools \
r-spatial \
r-squarem \
r-stringi \
r-stringr \
r-survival \
r-sys \
r-teachingdemos \
r-testthat \
r-tibble \
r-tidyr \
r-tidyselect \
r-tidyverse \
r-timedate \
r-tinytex \
r-usethis \
r-utf8 \
r-uuid \
r-vctrs \
r-whisker \
r-withr \
r-xfun \
r-xml2 \
r-xopen \
r-xtable \
r-yaml \
r-zip
ENV R_HOME=/usr/lib/R
# Add extra Python modules.
ENV PYTHONPATH=/opt/python/packages
RUN mkdir -p "${PYTHONPATH}"
# Add extra jars.
ENV SPARK_EXTRA_JARS_DIR=/opt/spark/jars/
ENV SPARK_EXTRA_CLASSPATH='/opt/spark/jars/*'
RUN mkdir -p "${SPARK_EXTRA_JARS_DIR}"
# Uncomment below and replace EXTRA_JAR_NAME with the jar file name.
# COPY "EXTRA_JAR_NAME" "${SPARK_EXTRA_JARS_DIR}"
# Create the 'spark' group/user.
# The GID and UID must be 1099. Home directory is required.
RUN groupadd -g 1099 spark
RUN useradd -u 1099 -g 1099 -d /home/spark -m spark
USER spark
Paso 3: Comandos de compilación y envío
Ejecuta estos comandos para compilar y subir tu imagen de contenedor a Artifact Registry con Cloud Build.
Crea el bucket de Cloud Storage:
gcloud storage buckets create gs://${BUCKET_NAME} --project=${PROJECT_ID} \ --location=${REGION}Crea el repositorio de Artifact Registry:
gcloud artifacts repositories create ${REPO_NAME} \ --repository-format=docker --location=${REGION} --description="Custom Dataproc Serverless images"Compila y envía la imagen con Cloud Build:
gcloud builds submit --tag ${REGION}-docker.pkg.dev/${PROJECT_ID}/${REPO_NAME}/spark-custom:latest .
Paso 4: Envío de trabajos
Implementa el trabajo definiendo el entorno de ejecución --version=2.3 para evitar problemas de desvío de versiones. En los entornos de producción, se recomienda proporcionar la versión de la imagen en lugar de la etiqueta :latest.
- Permisos: Asegúrate de que la cuenta de servicio adecuada tenga el rol de **Lector de Artifact Registry** (
roles/artifactregistry.reader) en el repositorio de Artifact Registry (recomendado) o en el proyecto que aloja la imagen de contenedor. Esto es especialmente importante si la imagen se aloja en un proyecto diferente de donde se ejecuta la carga de trabajo.- Para las versiones de entorno de ejecución anteriores a
3.0, otorga este permiso a la cuenta de servicio de ejecución de la carga de trabajo o de la sesión.- Para las versiones de entorno de ejecución
3.0y posteriores, otorga este permiso a la cuenta de servicio del agente de servicio del nodo de Dataproc Resource Manager.
- Para las versiones de entorno de ejecución
- Para las versiones de entorno de ejecución anteriores a
gcloud dataproc batches submit pyspark \
file:///usr/lib/spark/examples/src/main/python/pi.py \
--region=${REGION} \
--project=${PROJECT_ID} \
--version=2.3 \
--container-image=${REGION}-docker.pkg.dev/${PROJECT_ID}/${REPO_NAME}/spark-custom:latest \
-- 10