Questa pagina è stata tradotta dall'API Cloud Translation.

Personalizza l'ambiente di runtime del tuo job Spark con Docker su YARN

La funzionalità Dataproc Docker on YARN consente di creare e utilizzare un'immagine Docker per personalizzare Ambiente di runtime del job Spark. L'immagine può includere personalizzazioni di le dipendenze Java, Python e R e al jar del job.

Limitazioni

L'assistenza o la disponibilità delle funzionalità non è disponibile con:

Versioni immagine Dataproc precedenti alla 2.0.49 (non disponibili nelle immagini 1.5)
Job MapReduce (supportati solo per job Spark)
Modalità client Spark (supportata solo con la modalità cluster Spark)
Cluster Kerberos: la creazione del cluster non va a buon fine se crei un cluster con Docker su YARN e Kerberos abilitati.
Personalizzazioni di JDK, Hadoop e Spark: JDK, Hadoop e Spark host vengono utilizzati, non le tue personalizzazioni.

crea un'immagine Docker

Il primo passaggio per personalizzare l'ambiente Spark è creando un'immagine Docker.

Dockerfile

Puoi usare il Dockerfile seguente come esempio, apportando modifiche e per soddisfare le tue esigenze.

FROM debian:10-slim

# Suppress interactive prompts.
ENV DEBIAN_FRONTEND=noninteractive

# Required: Install utilities required by Spark scripts.
RUN apt update && apt install -y procps tini

# Optional: 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}"
COPY *.jar "${SPARK_EXTRA_JARS_DIR}"

# Optional: Install and configure Miniconda3.
ENV CONDA_HOME=/opt/miniconda3
ENV PYSPARK_PYTHON=${CONDA_HOME}/bin/python
ENV PYSPARK_DRIVER_PYTHON=${CONDA_HOME}/bin/python

ENV PATH=${CONDA_HOME}/bin:${PATH}
COPY Miniconda3-py39_4.10.3-Linux-x86_64.sh .
RUN bash Miniconda3-py39_4.10.3-Linux-x86_64.sh -b -p /opt/miniconda3 \
  && ${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 --prepend channels conda-forge \
  && ${CONDA_HOME}/bin/conda config --system --set channel_priority strict

# Optional: Install Conda packages.
#
# The following packages are installed in the default image. It is strongly
# recommended to include all of them.
#
# Use mamba to install packages quickly.
RUN ${CONDA_HOME}/bin/conda install mamba -n base -c conda-forge \
    && ${CONDA_HOME}/bin/mamba install \
      conda \
      cython \
      fastavro \
      fastparquet \
      gcsfs \
      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 \
      koalas \
      matplotlib \
      nltk \
      numba \
      numpy \
      openblas \
      orc \
      pandas \
      pyarrow \
      pysal \
      pytables \
      python \
      regex \
      requests \
      rtree \
      scikit-image \
      scikit-learn \
      scipy \
      seaborn \
      sqlalchemy \
      sympy \
      virtualenv

# Optional: Add extra Python modules.
ENV PYTHONPATH=/opt/python/packages
RUN mkdir -p "${PYTHONPATH}"
COPY test_util.py "${PYTHONPATH}"

# Required: Create the 'yarn_docker_user' group/user.
# The GID and UID must be 1099. Home directory is required.
RUN groupadd -g 1099 yarn_docker_user
RUN useradd -u 1099 -g 1099 -d /home/yarn_docker_user -m yarn_docker_user
USER yarn_docker_user

Crea ed esegui il push dell'immagine

Di seguito sono riportati i comandi per creare ed eseguire il push dell'immagine Docker di esempio, può apportare modifiche in base alle personalizzazioni.

# Increase the version number when there is a change to avoid referencing
# a cached older image. Avoid reusing the version number, including the default
# `latest` version.
IMAGE=gcr.io/my-project/my-image:1.0.1

# Download the BigQuery connector.
gcloud storage cp \
  gs://spark-lib/bigquery/spark-bigquery-with-dependencies_2.12-0.22.2.jar .

# Download the Miniconda3 installer.
wget https://repo.anaconda.com/miniconda/Miniconda3-py39_4.10.3-Linux-x86_64.sh

# Python module example:
cat >test_util.py <<EOF
def hello(name):
  print("hello {}".format(name))

def read_lines(path):
  with open(path) as f:
    return f.readlines()
EOF

# Build and push the image.
docker build -t "${IMAGE}" .
docker push "${IMAGE}"

Crea un cluster Dataproc

Dopo aver creato un'immagine Docker che personalizza il tuo ambiente Spark, crea un cluster Dataproc che utilizzerà la tua immagine Docker durante l'esecuzione dei job Spark.

gcloud

gcloud dataproc clusters create CLUSTER_NAME \
    --region=REGION \
    --image-version=DP_IMAGE \
    --optional-components=DOCKER \
    --properties=dataproc:yarn.docker.enable=true,dataproc:yarn.docker.image=DOCKER_IMAGE \
    other flags

Sostituisci quanto segue:

CLUSTER_NAME: il nome del cluster.
REGION: la regione del cluster.
DP_IMAGE: la versione immagine Dataproc deve essere 2.0.49 o successiva (--image-version=2.0 utilizzerà una versione secondaria qualificata dopo il giorno 2.0.49).
--optional-components=DOCKER: attiva il parametro Componente Docker sul cluster.
--properties flag:
- dataproc:yarn.docker.enable=true: proprietà obbligatoria per attivare Funzionalità Docker on YARN di Dataproc.
- dataproc:yarn.docker.image: proprietà facoltativa che puoi aggiungere per specificare DOCKER_IMAGE tramite seguente formato di denominazione delle immagini di Container Registry: {hostname}/{project-id}/{image}:{tag}.
  Esempio:
```
dataproc:yarn.docker.image=gcr.io/project-id/image:1.0.1
```
  Requisito: devi ospitare l'immagine Docker su Container Registry o Artifact Registry. (Dataproc non può recuperare di container di altri registry).
  
  Consiglio: aggiungi questa proprietà quando crei il cluster per memorizzare nella cache l'immagine Docker ed evitare timeout YARN in un secondo momento, invii un job che utilizza l'immagine.

Se dataproc:yarn.docker.enable è impostato su true, Dataproc aggiorna le configurazioni Hadoop e Spark per abilitare la funzionalità Docker on YARN in nel cluster. Ad esempio, spark.submit.deployMode è impostato su cluster e spark.yarn.appMasterEnv.YARN_CONTAINER_RUNTIME_DOCKER_MOUNTS e spark.executorEnv.YARN_CONTAINER_RUNTIME_DOCKER_MOUNTS impostati per montare dall'host al container.

invia un job Spark al cluster

Dopo aver creato un cluster Dataproc, invia un job Spark al cluster che utilizza la tua immagine Docker. L'esempio in questa sezione invia un job PySpark al cluster.

Imposta le proprietà del job:

# Set the Docker image URI.
IMAGE=(e.g., gcr.io/my-project/my-image:1.0.1)

# Required: Use `#` as the delimiter for properties to avoid conflicts.
JOB_PROPERTIES='^#^'

# Required: Set Spark properties with the Docker image.
JOB_PROPERTIES="${JOB_PROPERTIES}#spark.yarn.appMasterEnv.YARN_CONTAINER_RUNTIME_DOCKER_IMAGE=${IMAGE}"
JOB_PROPERTIES="${JOB_PROPERTIES}#spark.executorEnv.YARN_CONTAINER_RUNTIME_DOCKER_IMAGE=${IMAGE}"

# Optional: Add custom jars to Spark classpath. Don't set these properties if
# there are no customizations.
JOB_PROPERTIES="${JOB_PROPERTIES}#spark.driver.extraClassPath=/opt/spark/jars/*"
JOB_PROPERTIES="${JOB_PROPERTIES}#spark.executor.extraClassPath=/opt/spark/jars/*"

# Optional: Set custom PySpark Python path only if there are customizations.
JOB_PROPERTIES="${JOB_PROPERTIES}#spark.pyspark.python=/opt/miniconda3/bin/python"
JOB_PROPERTIES="${JOB_PROPERTIES}#spark.pyspark.driver.python=/opt/miniconda3/bin/python"

# Optional: Set custom Python module path only if there are customizations.
# Since the `PYTHONPATH` environment variable defined in the Dockerfile is
# overridden by Spark, it must be set as a job property.
JOB_PROPERTIES="${JOB_PROPERTIES}#spark.yarn.appMasterEnv.PYTHONPATH=/opt/python/packages"
JOB_PROPERTIES="${JOB_PROPERTIES}#spark.executorEnv.PYTHONPATH=/opt/python/packages"

Note:

Vedi Avvio di applicazioni mediante container Docker informazioni sulle proprietà correlate.

gcloud

Invia il job al cluster.

gcloud dataproc jobs submit pyspark PYFILE \
    --cluster=CLUSTER_NAME \
    --region=REGION \
    --properties=${JOB_PROPERTIES}

Sostituisci quanto segue:

PYFILE: il percorso del file del job PySpark. È possibile un percorso file locale o l'URI del file in Cloud Storage (gs://BUCKET_NAME/PySpark filename).
CLUSTER_NAME: il nome del cluster.
REGION: la regione del cluster.