Usar contêineres personalizados com o Dataproc sem servidor para Spark

O Dataproc sem servidor para Spark executa cargas de trabalho em contêineres do Docker. O contêiner fornece o ambiente de execução para os processos de driver e executor da carga de trabalho. Por padrão, o Dataproc sem servidor para Spark usa uma imagem de contêiner que inclui os pacotes padrão Spark, Java, Python e R associada a uma versão de lançamento do ambiente de execução. A API batches do Dataproc Serverless para Spark permite usar uma imagem de contêiner personalizada em vez da imagem padrão. Normalmente, uma imagem de contêiner personalizada adiciona dependências de Java ou Python da carga de trabalho do Spark que não são fornecidas pela imagem de contêiner padrão. Importante: não inclua o Spark na imagem de contêiner personalizada. O Dataproc Serverless para Spark vai montar o Spark no contêiner no momento da execução.

Enviar uma carga de trabalho em lote do Spark usando uma imagem de contêiner 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"
}

Criar uma imagem de contêiner personalizada

As imagens de contêiner personalizadas do Dataproc Serverless para Spark são imagens do Docker. Você pode usar as ferramentas para criar imagens Docker e criar imagens de contêiner personalizadas, mas há que as imagens precisam atender para serem compatíveis com o Dataproc sem servidor para Spark. As seções a seguir explicam essas condições.

Sistema operacional

Você pode escolher qualquer imagem do sistema operacional como a imagem de base do contêiner personalizado. Recomendação: prefira as imagens padrão do Debian 11 (por exemplo, debian:11-slim). desde que foram submetidos aos testes para evitar problemas de compatibilidade.

Utilitários

É necessário incluir os seguintes pacotes de utilitários, que são necessários para executar o Spark, na imagem de contêiner personalizada:

• procps
• tini

Para executar o XGBoost no Spark (Java ou Scala), é necessário incluir libgomp1

Usuário do contêiner

O Dataproc Serverless para Spark executa contêineres como o usuário spark do Linux com uma UID 1099 e um GID 1099. As diretivas USER definidas em arquivos Docker de imagem de contêiner personalizados são ignoradas no momento da execução. Use o UID e o GID para permissões do sistema de arquivos. Por exemplo, se você adicionar um arquivo jar em /opt/spark/jars/my-lib.jar na imagem como dependência da carga de trabalho, é preciso dar permissão de leitura ao usuário spark para o .

Streaming de imagens

O Dataproc Serverless para Spark normalmente inicia uma carga de trabalho que exige uma imagem de contêiner personalizada fazendo o download da imagem inteira para o disco. Isso pode significar um atraso na inicialização especialmente para clientes com imagens grandes.

Em vez disso, use o streaming de imagens, que é um método para extrair dados de imagens em uma conforme necessário. Assim, a carga de trabalho pode ser iniciada sem esperar imagem para download, possivelmente melhorando o tempo de inicialização. Para ativar a imagem é preciso ativar o API Container File System. Você também precisa armazenar as imagens do contêiner no Artifact Registry, e o repositório do Artifact Registry precisa estar na mesma região que sua carga de trabalho do Dataproc ou em uma multirregião que corresponda à região em que a carga de trabalho está em execução. Se o Dataproc não oferecer suporte à imagem ou se o serviço de streaming de imagem não estiver disponível, nossa implementação de streaming vai fazer o download de toda a imagem. Não oferecemos suporte aos seguintes recursos para streaming de imagens:

• Imagens com camadas vazias ou camadas duplicadas
• Imagens que usam o manifesto de imagem V2, versão 1 do esquema

Nesses casos, o Dataproc extrai a imagem inteira antes de iniciar a carga de trabalho.

Spark

Não inclua o Spark na imagem personalizada do contêiner. No ambiente de execução, o Dataproc sem servidor para Spark monta binários e configurações do Spark do host no contêiner: binários são montados no diretório /usr/lib/spark e as configurações são montados no /etc/spark/conf. Os arquivos existentes nesses diretórios são substituídos pelo Dataproc Serverless para Spark no momento da execução.

Java Runtime Environment

Não inclua seu próprio ambiente de execução do Java (JRE) na imagem de contêiner personalizada. No ambiente de execução, o Dataproc sem servidor para Spark monta OpenJDK do host no contêiner do Docker. Se você incluir uma JRE na imagem de contêiner personalizada, ela será ignorada.

Pacotes Java

É possível incluir arquivos JAR como dependências de carga de trabalho do Spark na imagem de contêiner personalizada e definir a variável de ambiente SPARK_EXTRA_CLASSPATH para incluir os JARs. O Dataproc Serverless para Spark adiciona o valor da variável env no classpath dos processos da JVM do Spark. Recomendação: coloque os frascos no diretório /opt/spark/jars e defina SPARK_EXTRA_CLASSPATH como /opt/spark/jars/*.

É possível incluir o jar da carga de trabalho na imagem de contêiner personalizada e, em seguida, fazer referência a ele com um caminho local ao enviar a carga de trabalho, por exemplo, file:///opt/spark/jars/my-spark-job.jar (consulte Enviar uma carga de trabalho em lote do Spark usando uma imagem de contêiner personalizada para conferir um exemplo).

Pacotes do Python

Por padrão, o Dataproc sem servidor para montagens do Spark Conda do host para diretório /opt/dataproc/conda no contêiner no ambiente de execução. PYSPARK_PYTHON está definida como /opt/dataproc/conda/bin/python. O diretório base, /opt/dataproc/conda/bin está incluído em PATH.

É possível incluir o ambiente Python com pacotes em um diretório diferente na imagem do contêiner personalizada, por exemplo, em /opt/conda, e definir a variável de ambiente PYSPARK_PYTHON como /opt/conda/bin/python.

A imagem personalizada do contêiner pode incluir outros módulos Python que não fazem parte do ambiente Python, por exemplo, scripts Python com funções utilitárias. Defina a variável de ambiente PYTHONPATH para incluir os diretórios em que os módulos estão localizados.

Ambiente R

Você pode personalizar o ambiente R em sua imagem personalizada de contêiner usando uma das opções a seguir:

• Use o Conda para gerenciar e instalar pacotes de R do canal conda-forge.
• Adicione um repositório R para o SO Linux da imagem do contêiner e instale pacotes R usando o gerenciador de pacotes do SO Linux (consulte o índice de pacotes de software R).

Ao usar qualquer uma das opções, defina a variável de ambiente R_HOME para apontar para o ambiente R personalizado. Exceção: se você estiver usando o Conda para gerenciar o ambiente R e personalizar o ambiente Python, não será necessário definir a variável de ambiente R_HOME. Ela será definida automaticamente com base na variável de ambiente PYSPARK_PYTHON.

Exemplo de build de imagem de contêiner personalizada

Esta seção inclui um exemplo de criação de imagem de contêiner personalizada, começando com um Dockerfile de amostra.

Dockerfile

# Debian 11 is recommended.
FROM debian:11-slim

# Suppress interactive prompts
ENV DEBIAN_FRONTEND=noninteractive

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

# (Optiona) Install utilities required by XGBoost for Spark.
RUN apt install -y procps libgomp1

# Enable jemalloc2 as default memory allocator
ENV LD_PRELOAD=/usr/lib/x86_64-linux-gnu/libjemalloc.so.2

# (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}"

#Uncomment below and replace EXTRA_JAR_NAME with the jar file name.
#COPY "EXTRA_JAR_NAME" "${SPARK_EXTRA_JARS_DIR}"

# (Optional) Install and configure Miniconda3.
ENV CONDA_HOME=/opt/miniconda3
ENV PYSPARK_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
# Packages ipython and ipykernel are required if using custom conda and want to
# use this container for running notebooks.
RUN ${CONDA_HOME}/bin/conda install ipython ipykernel

# (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}"

# (Optional) Install R and R libraries.
RUN apt update \
  && apt install -y gnupg \
  && apt-key adv --no-tty \
      --keyserver "hkp://keyserver.ubuntu.com:80" \
      --recv-keys E19F5F87128899B192B1A2C2AD5F960A256A04AF \
  && echo "deb http://cloud.r-project.org/bin/linux/debian bullseye-cran40/" \
      >/etc/apt/sources.list.d/cran-r.list \
  && apt update \
  && apt install -y \
      libopenblas-base \
      libssl-dev \
      r-base \
      r-base-dev \
      r-recommended \
      r-cran-blob

ENV R_HOME=/usr/lib/R

# (Required) 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

Comandos de build

Executar no diretório do Dockerfile.

IMAGE=gcr.io/my-project/my-image:1.0.1

# 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}"