Usa contenedores personalizados con Dataproc Serverless para Spark

Dataproc Serverless para Spark ejecuta cargas de trabajo en 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, Dataproc Serverless para Spark usa una imagen de contenedor que incluye los paquetes predeterminados de Spark, Java, Python y R asociados con una versión de lanzamiento del entorno de ejecución. La API de lotes de Dataproc Serverless para 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 la imagen de contenedor personalizada. Dataproc Serverless para Spark activará Spark en el contenedor durante el tiempo de ejecución.

Envía una carga de trabajo por lotes de Spark con una imagen de contenedor personalizada

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

POST https://dataproc.googleapis.com/v1/projects/project-id/locations/region/batches

{
  "runtimeConfig":{
    "containerImage":"custom-container-image
  },
  "sparkBatch":{
    "jarFileUris":[
      "jar-uri"
    ],
    "mainClass":"class"
  }
}

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://dataproc.googleapis.com/v1/projects/project-id/locations/region/batches"

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://dataproc.googleapis.com/v1/projects/project-id/locations/region/batches" | Select-Object -Expand Content

{
"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 contenedores personalizados de Dataproc sin servidores para Spark son imágenes de Docker. Puedes usar las herramientas para compilar imágenes de Docker para compilar imágenes de contenedores personalizadas, pero hay condiciones que las imágenes deben cumplir para ser compatibles con Dataproc sin servidor para 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 utilidad, que son necesarios para ejecutar Spark, en la imagen de contenedor personalizada:

• procps
• tini

Para ejecutar XGBoost desde Spark (Java o Scala), debes incluir libgomp1.

Usuario del contenedor

Dataproc Serverless para Spark ejecuta contenedores como el usuario spark de Linux con un UID 1099 y un GID 1099. Las directivas USER establecidas en los Dockerfiles de imágenes de contenedores personalizados se ignoran durante el tiempo 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 la carga de trabajo, debes otorgarle al usuario spark permiso de lectura al archivo.

Transmisión de imágenes

Por lo general, Dataproc sin servidores para Spark comienza una carga de trabajo que requiere una imagen de contenedor personalizada descargando toda la imagen en el disco. Esto puede significar una demora en el tiempo de inicialización, sobre todo 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 podría mejorar el tiempo de inicialización. Para habilitar la transmisión de imágenes, debes habilitar la API de Container File System. 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 Dataproc o en una multirregión que corresponda a la región en la que se ejecuta la carga de trabajo. Si Dataproc 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 se admiten los siguientes elementos 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, Dataproc extrae toda la imagen antes de iniciar la carga de trabajo.

Spark

No incluyas Spark en la imagen de contenedor personalizada. Durante el tiempo de ejecución, Dataproc Serverless para Spark activa los objetos binarios y los archivos de configuración de Spark del host en el contenedor: los objetos binarios se activan en el directorio /usr/lib/spark y los archivos de configuración se activan en el directorio /etc/spark/conf. Dataproc Serverless para Spark anula los archivos existentes en estos directorios durante el tiempo de ejecución.

Java Runtime Environment

No incluyas tu propio entorno de ejecución de Java (JRE) en la imagen de contenedor personalizado. Durante el tiempo de ejecución, Dataproc Serverless para Spark activa OpenJDK desde el host en el contenedor. Si incluyes un JRE en la 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 configurar la variable de entorno SPARK_EXTRA_CLASSPATH para incluir los archivos JAR. Dataproc Serverless para Spark añadirá 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 la 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 Cómo enviar una carga de trabajo por lotes de Spark con una imagen de contenedor personalizada para ver un ejemplo).

Paquetes de Python

De forma predeterminada, Dataproc Serverless para Spark activa Conda desde el host al directorio /opt/dataproc/conda en el contenedor durante el tiempo de ejecución. PYSPARK_PYTHON se configura como /opt/dataproc/conda/bin/python. Su directorio base, /opt/dataproc/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 forman parte del entorno de Python, por ejemplo, secuencias de comandos de Python con funciones de utilidad. Establece la variable de entorno PYTHONPATH para incluir 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 gestionar tu entorno de R y personalizar tu entorno de Python, no necesitas configurar la variable de entorno R_HOME, ya que se establece 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 contenedores personalizados, que incluyen Dockerfiles de muestra, seguidos de un comando de compilación. Un ejemplo incluye la configuración mínima necesaria para compilar una imagen. El otro ejemplo incluye ejemplos de configuración adicional, incluidas las bibliotecas de Python y R.

# 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 jemalloc2 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
    

# 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 jemalloc2 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

# 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
      

Comando de compilación

Ejecuta el siguiente comando en el directorio Dockerfile para compilar y enviar la imagen personalizada a Artifact Registry.

# Build and push the image.
gcloud builds submit --region=REGION \
    --tag REGION-docker.pkg.dev/PROJECT/REPOSITORY/IMAGE_NAME:IMAGE_VERSION