"Managed Service for Apache Spark" is the new name for the product formerly known as "Dataproc on Compute Engine" (cluster deployment) and "Google Cloud Serverless for Apache Spark" (serverless deployment).

Google utilizza la tecnologia AI per tradurre i contenuti nella tua lingua preferita. Le traduzioni generate dall'AI potrebbero contenere errori.

Crea un'immagine container personalizzata di Google Kubernetes Engine

Puoi specificare un'immagine container personalizzata da utilizzare con Managed Service for Apache Spark su GKE . L'immagine container personalizzata deve utilizzare una delle immagini Spark di base di Managed Service for Apache Spark su GKE.

Utilizzare un'immagine container personalizzata

Per utilizzare un'immagine container personalizzata di Managed Service for Apache Spark su GKE, imposta spark.kubernetes.container.image property quando crei un cluster virtuale Managed Service for Apache Spark su GKE o invii un job Spark al cluster.

Esempio di creazione del cluster gcloud CLI:

gcloud dataproc clusters gke create "${DP_CLUSTER}" \
    --properties=spark:spark.kubernetes.container.image=custom-image \
    ... other args ...

Esempio di invio di job gcloud CLI:

gcloud dataproc jobs submit spark \
    --properties=spark.kubernetes.container.image=custom-image \
    ... other args ...

Impostazioni e requisiti delle immagini container personalizzate

Immagini di base

Puoi utilizzare gli strumenti docker per creare Docker personalizzati in base a una delle immagini Spark di base di Managed Service for Apache Spark su GKE pubblicate.

Utente del container

Managed Service for Apache Spark su GKE esegue i container Spark come utente Linux spark con un UID 1099 e un GID 1099. Utilizza UID e GID per le autorizzazioni del file system. Ad esempio, se aggiungi un file JAR in /opt/spark/jars/my-lib.jar nell'immagine come dipendenza del workload, devi concedere all'utente spark l'autorizzazione di lettura per il file.

Componenti

Java:la variabile di ambiente JAVA_HOME indica la posizione dell'installazione di Java. Il valore predefinito attuale è /usr/lib/jvm/adoptopenjdk-8-hotspot-amd64, che è soggetto a modifiche (consulta le note di rilascio di Managed Service for Apache Spark per informazioni aggiornate).
- Se personalizzi l'ambiente Java, assicurati che JAVA_HOME sia impostato sulla posizione corretta e che PATH includa il percorso dei file binari.
Python:le immagini Spark di base di Managed Service for Apache Spark su GKE hanno Miniconda3 installato in /opt/conda. CONDA_HOME punta a questa posizione, ${CONDA_HOME}/bin è incluso in PATH e PYSPARK_PYTHON è impostato su ${CONDA_HOME}/python.
- Se personalizzi Conda, assicurati che CONDA_HOME punti alla home directory di Conda,${CONDA_HOME}/bin sia incluso in PATH e PYSPARK_PYTHON sia impostato su ${CONDA_HOME}/python..
- Puoi installare, rimuovere e aggiornare i pacchetti nell'ambiente di base predefinito o creare un nuovo ambiente, ma è consigliabile che l'ambiente includa tutti i pacchetti installati nell'ambiente di base dell'immagine container di base.
- Se aggiungi moduli Python, ad esempio uno script Python con funzioni di utilità, all'immagine container, includi le directory dei moduli in PYTHONPATH.
Spark: Spark è installato in /usr/lib/spark e SPARK_HOME punta a questa posizione. Spark non può essere personalizzato. Se viene modificata, l'immagine del contenitore verrà rifiutata o non funzionerà correttamente.
- Job: puoi personalizzare le dipendenze dei job Spark. SPARK_EXTRA_CLASSPATH definisce il classpath aggiuntivo per i processi JVM Spark. Consiglio: inserisci i file JAR in /opt/spark/jars e imposta SPARK_EXTRA_CLASSPATH su /opt/spark/jars/*.
  Se incorpori il file JAR del job nell'immagine, la directory consigliata è /opt/spark/job. Quando invii il job, puoi farvi riferimento con un percorso locale, ad esempio file:///opt/spark/job/my-spark-job.jar.
- Connettore Cloud Storage: il connettore Cloud Storage è installato in /usr/lib/spark/jars.
- Utilità: i pacchetti di utilità procps e tini sono necessari per eseguire Spark. Queste utilità sono incluse nelle immagini Spark di base, quindi le immagini personalizzate non devono essere reinstallate.
- Entrypoint: Managed Service for Apache Spark su GKE ignora qualsiasi modifica apportata alle primitive ENTRYPOINT e CMD nell'immagine container.
- Script di inizializzazione:puoi aggiungere uno script di inizializzazione facoltativo in /opt/init-script.sh. Uno script di inizializzazione può scaricare file da Cloud Storage, avviare un proxy all'interno del container, chiamare altri script ed eseguire altre attività di avvio.
  Lo script di punto di ingresso chiama lo script di inizializzazione con tutti gli argomenti della riga di comando ($@) prima di avviare il driver Spark, l'executor Spark e altri processi. Lo script di inizializzazione può selezionare il tipo di processo Spark in base al primo argomento ($1): i valori possibili includono spark-submit per i contenitori driver e executor per i contenitori executor.
Configurazioni:le configurazioni Spark si trovano in /etc/spark/conf. La variabile di ambiente SPARK_CONF_DIR punta a questa posizione.

Non personalizzare le configurazioni di Spark nell'immagine container. In alternativa, invia le proprietà tramite l'API Managed Service for Apache Spark su GKE per i seguenti motivi:
- Alcune proprietà, come le dimensioni della memoria dell'executor, vengono determinate in fase di tempo di esecuzione, non in fase di tempo di compilazione dell'immagine container; devono essere inserite da Managed Service for Apache Spark su GKE .
- Managed Service for Apache Spark su GKE impone restrizioni alle proprietà fornite dagli utenti. Managed Service for Apache Spark su GKE monta le configurazioni da configMap in /etc/spark/conf nel container, sostituendo le impostazioni incorporate nell'immagine.

Immagini Spark di base

Managed Service for Apache Spark supporta le seguenti immagini container Spark di base:

Spark 3.5: ${REGION}-docker.pkg.dev/cloud-dataproc/spark/dataproc_2.2

Esempio di creazione di un'immagine container personalizzata

Dockerfile di esempio

FROM us-central1-docker.pkg.dev/cloud-dataproc/spark/dataproc_2.0:latest

# Change to root temporarily so that it has permissions to create dirs and copy
# files.
USER root

# Add a BigQuery connector jar.
ENV SPARK_EXTRA_JARS_DIR=/opt/spark/jars/
ENV SPARK_EXTRA_CLASSPATH='/opt/spark/jars/*'
RUN mkdir -p "${SPARK_EXTRA_JARS_DIR}" \
    && chown spark:spark "${SPARK_EXTRA_JARS_DIR}"
COPY --chown=spark:spark \
    spark-bigquery-with-dependencies_2.12-0.22.2.jar "${SPARK_EXTRA_JARS_DIR}"

# Install Cloud Storage client Conda package.
RUN "${CONDA_HOME}/bin/conda" install google-cloud-storage

# Add a custom Python file.
ENV PYTHONPATH=/opt/python/packages
RUN mkdir -p "${PYTHONPATH}"
COPY test_util.py "${PYTHONPATH}"

# Add an init script.
COPY --chown=spark:spark init-script.sh /opt/init-script.sh

# (Optional) Set user back to `spark`.
USER spark

Crea l'immagine container

Esegui i seguenti comandi nella directory Dockerfile

Imposta l'immagine (ad esempio us-central1-docker.pkg.dev/my-project/spark/spark-test-image:latest) e passa alla directory di compilazione.
```
IMAGE=custom container image \
    BUILD_DIR=$(mktemp -d) \
    cd "${BUILD_DIR}"
```

Scarica il connettore BigQuery.

gcloud storage cp \
    gs://spark-lib/bigquery/spark-bigquery-with-dependencies_2.12-0.22.2.jar .

Crea un file di esempio Python.

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

Crea uno script init di esempio.

cat >init-script.sh <<EOF
echo "hello world" >/tmp/init-script.out
EOF

Crea ed esegui il push dell'immagine.

docker build -t "${IMAGE}" . && docker push "${IMAGE}"