Contenitore Dataproc per Spark

Google Distributed Cloud (GDC) con air gap fornisce un container Dataproc per Spark. Si tratta di un ambiente Apache Spark per il trattamento dati. Per saperne di più su Apache Spark, consulta https://spark.apache.org/. Utilizza i container di Dataproc Container per Spark per eseguire applicazioni Spark nuove o esistenti all'interno di un cluster Kubernetes Distributed Cloud con modifiche minime. Se hai familiarità con gli strumenti Spark, puoi continuare a utilizzarli.

Definisci la tua applicazione Spark in un file YAML e Distributed Cloud alloca le risorse per te. Il container Dataproc Container for Spark si avvia in pochi secondi. Gli esecutori Spark eseguono lo scale up o lo scale down in base alle tue esigenze.

Configura i container di Dataproc Container for Spark su Distributed Cloud per utilizzare hardware specializzato, come nodi hardware specializzati o GPU.

Questo documento è rivolto ai membri del gruppo di operatori di applicazioni che gestiscono applicazioni Apache Spark utilizzando il servizio Dataproc Container for Spark all'interno dei progetti GDC. Per saperne di più, consulta la documentazione sui segmenti di pubblico per GDC con air gap.

Prima di iniziare

Prima di eseguire applicazioni Spark utilizzando Dataproc Container per Spark, devi assicurarti che il servizio sia disponibile, richiedere le autorizzazioni necessarie, preparare l'ambiente e creare un account di servizio.

Esegui il deployment del servizio Dataproc Container for Spark

L'amministratore della piattaforma (PA) deve installare i servizi del Marketplace per te prima che tu possa utilizzarli. Contatta il tuo PA se hai bisogno di Dataproc Container per Spark. Per saperne di più, consulta Installa un pacchetto software di GDC Marketplace.

Richiedi ruoli IAM

Contatta l'amministratore dell'organizzazione IAM o l'amministratore del progetto IAM per richiedere i seguenti ruoli in base alle attività che devi eseguire:

  • Namespace Admin (namespace-admin): crea, aggiorna ed elimina le risorse del progetto all'interno dello spazio dei nomi del progetto nel cluster utente.
  • Visualizzatore progetto (project-viewer): visualizza un progetto esistente e le relative risorse.

L'amministratore dell'organizzazione IAM può concedere questi ruoli per qualsiasi progetto all'interno dell'organizzazione. L'amministratore del progetto IAM può concedere questi ruoli nell'ambito del proprio progetto specifico.

prepara l'ambiente

Configura il account di servizio per il servizio Dataproc Container for Spark

Per utilizzare il servizio Dataproc Container per Spark, devi disporre di un account di servizio nei cluster utente. Il container Dataproc per Spark crea un pod del driver Spark per eseguire un'applicazione Spark. Un pod driver Spark richiede un service account Kubernetes nello spazio dei nomi del pod con le autorizzazioni per eseguire le seguenti azioni:

  • Creare, recuperare, elencare ed eliminare i pod executor.
  • Crea un servizio headless Kubernetes per il driver.

Prima di eseguire un'applicazione Spark, completa i seguenti passaggi per assicurarti di avere un account di servizio con le autorizzazioni precedenti nello spazio dei nomi foo:

  1. Crea un account di servizio per un pod del driver Spark da utilizzare nello spazio dei nomi foo:

    kubectl create serviceaccount spark --kubeconfig AO_USER_KUBECONFIG --namespace=foo
    
  2. Crea un ruolo per concedere le autorizzazioni per creare, recuperare, elencare ed eliminare i pod executor e crea un servizio headless Kubernetes per il driver nello spazio dei nomi foo:

    kubectl create role spark-driver --kubeconfig AO_USER_KUBECONFIG --verb=* \
    --resource=pods,services,configmaps,persistentvolumeclaims \
    --namespace=foo
    
  3. Crea un'associazione di ruoli per concedere l'accesso al ruolo del account di servizio nello spazio dei nomi foo:

    kubectl create --kubeconfig AO_USER_KUBECONFIG \
    rolebinding spark-spark-driver \
    --role=spark-driver --serviceaccount=foo:spark \
    --namespace=foo
    

Esegui applicazioni Spark 3 di esempio

La containerizzazione delle applicazioni Spark semplifica l'esecuzione di applicazioni per big data on-premise utilizzando Distributed Cloud. In qualità di Application Operator (AO), esegui le applicazioni Spark specificate negli oggetti GKE del tipo di risorsa personalizzata SparkApplication.

Per eseguire e utilizzare un'applicazione Apache Spark 3 su Distributed Cloud, completa i seguenti passaggi:

  1. Esamina l'immagine spark-operator nel tuo progetto per trovare il $DATAPROC_IMAGE da utilizzare come riferimento nella tua applicazione Spark:

    export DATAPROC_IMAGE=$(kubectl get pod --kubeconfig AO_USER_KUBECONFIG \
    --selector app.kubernetes.io/name=spark-operator -n foo \
    -o=jsonpath='{.items[*].spec.containers[0].image}' \
    | sed 's/spark-operator/dataproc/')
    

    Ad esempio:

    export DATAPROC_IMAGE=10.200.8.2:10443/dataproc-service/private-cloud-devel/dataproc:3.1-dataproc-17
    
  2. Scrivi una specifica SparkApplication e memorizzala in un file YAML. Per saperne di più, consulta la sezione Scrivi una specifica dell'applicazione Spark.

  3. Invia, esegui e monitora l'applicazione Spark come configurata in una specifica SparkApplication sul cluster GKE con il comando kubectl. Per saperne di più, consulta la sezione Esempi di applicazioni.

  4. Controlla lo stato della richiesta.

  5. (Facoltativo) Esamina i log dell'applicazione. Per saperne di più, consulta la sezione Visualizza i log di un'applicazione Spark 3.

  6. Utilizza l'applicazione Spark per raccogliere e mostrare all'utente lo stato del driver e degli esecutori.

Scrivi una specifica dell'applicazione Spark

Una specifica SparkApplication include i seguenti componenti:

  • Il campo apiVersion.
  • Il campo kind.
  • Il campo metadata.
  • La sezione spec.

Per saperne di più, consulta la sezione Scrittura di una specifica SparkApplication su GitHub: https://github.com/kubeflow/spark-operator/blob/gh-pages/docs/user-guide.md#writing-a-sparkapplication-spec

Esempi di applicazioni

Questa sezione include i seguenti esempi con le relative specifiche SparkApplication per eseguire applicazioni Spark:

Spark Pi

Questa sezione contiene un esempio per eseguire un'applicazione Spark Pi ad alta intensità di calcolo che stima 𝛑 (pi greco) lanciando freccette in un cerchio.

Segui questi passaggi per eseguire Spark Pi:

  1. Applica il seguente esempio di specifica SparkApplication nel cluster utente:

    apiVersion: "sparkoperator.k8s.io/v1beta2"
    kind: SparkApplication
    metadata:
      name: spark-pi
      namespace: foo
    spec:
      type: Python
      pythonVersion: "3"
      mode: cluster
      image: "${DATAPROC_IMAGE?}"
      imagePullPolicy: IfNotPresent
      mainApplicationFile: "local:///usr/lib/spark/examples/src/main/python/pi.py"
      sparkVersion: "3.1.3"
      restartPolicy:
        type: Never
      driver:
        cores: 1
        coreLimit: "1000m"
        memory: "512m"
        serviceAccount: spark
      executor:
        cores: 1
        instances: 1
        memory: "512m"
    
  2. Verifica che l'esempio di specifica SparkApplication venga eseguito e completato in 1-2 minuti utilizzando il seguente comando:

    kubectl --kubeconfig AO_USER_KUBECONFIG get SparkApplication spark-pi -n foo
    
  3. Visualizza i log del driver per vedere il risultato:

    kubectl --kubeconfig AO_USER_KUBECONFIG logs spark-pi-driver -n foo | grep "Pi is roughly"
    

    L'output è simile al seguente:

    Pi is roughly 3.1407357036785184
    

Per maggiori informazioni, consulta le seguenti risorse:

  • Per il codice dell'applicazione, consulta l'articolo Stima di Pi della documentazione di Apache Spark: https://spark.apache.org/examples.html.
  • Per un file YAML Spark Pi di esempio, consulta Scrivi una specifica dell'applicazione Spark.

Spark SQL

Segui questi passaggi per eseguire Spark SQL:

  1. Per eseguire un'applicazione Spark SQL che seleziona il valore 1, utilizza la seguente query:

    select 1;
    
  2. Applica il seguente esempio di specifica SparkApplication nel cluster utente:

    apiVersion: "sparkoperator.k8s.io/v1beta2"
    kind: SparkApplication
    metadata:
      name: pyspark-sql-arrow
      namespace: foo
    spec:
      type: Python
      mode: cluster
      image: "${DATAPROC_IMAGE?}"
      imagePullPolicy: IfNotPresent
      mainApplicationFile: "local:///usr/lib/spark/examples/src/main/python/sql/arrow.py"
      sparkVersion: "3.1.3"
      restartPolicy:
        type: Never
      driver:
        cores: 1
        coreLimit: "1000m"
        memory: "512m"
        serviceAccount: spark
      executor:
        cores: 1
        instances: 1
        memory: "512m"
    
  3. Verifica che l'esempio di specifica SparkApplication venga eseguito e completato in meno di un minuto utilizzando il seguente comando:

    kubectl --kubeconfig AO_USER_KUBECONFIG get SparkApplication pyspark-sql-arrow -n foo
    

Spark MLlib

Segui questi passaggi per eseguire Spark MLlib:

  1. Utilizza il seguente esempio di Scala per eseguire un'istanza Spark MLlib che esegue l'analisi statistica e stampa un risultato nella console:

    import org.apache.spark.ml.linalg.{Matrix, Vectors}
    import org.apache.spark.ml.stat.Correlation
    import org.apache.spark.sql.Row
    
    val data = Seq(
      Vectors.sparse(4, Seq((0, 1.0), (3, -2.0))),
      Vectors.dense(4.0, 5.0, 0.0, 3.0),
      Vectors.dense(6.0, 7.0, 0.0, 8.0),
      Vectors.sparse(4, Seq((0, 9.0), (3, 1.0)))
    )
    
    val df = data.map(Tuple1.apply).toDF("features")
    val Row(coeff1: Matrix) = Correlation.corr(df, "features").head
    println(s"Pearson correlation matrix:\n $coeff1")
    
    val Row(coeff2: Matrix) = Correlation.corr(df, "features", "spearman").head
    println(s"Spearman correlation matrix:\n $coeff2")
    
  2. Applica il seguente esempio di specifica SparkApplication nel cluster utente:

    apiVersion: "sparkoperator.k8s.io/v1beta2"
    kind: SparkApplication
    metadata:
      name: spark-ml
      namespace: foo
    spec:
      type: Scala
      mode: cluster
      image: "${DATAPROC_IMAGE?}"
      imagePullPolicy: IfNotPresent
      mainClass: org.apache.spark.examples.ml.SummarizerExample
      mainApplicationFile: "local:///usr/lib/spark/examples/jars/spark-examples_2.12-3.1.3.jar"
      sparkVersion: "3.1.3"
      restartPolicy:
        type: Never
      driver:
        cores: 1
        coreLimit: "1000m"
        memory: "512m"
        serviceAccount: spark
      executor:
        cores: 1
        instances: 1
        memory: "512m"
    
  3. Verifica che l'esempio di specifica SparkApplication venga eseguito e completato in meno di un minuto utilizzando il seguente comando:

    kubectl --kubeconfig AO_USER_KUBECONFIG get SparkApplication spark-ml -n foo
    

SparkR

Segui questi passaggi per eseguire SparkR:

  1. Utilizza il seguente codice di esempio per eseguire un'istanza SparkR che carica un set di dati in bundle e stampa la prima riga:

    library(SparkR)
    sparkR.session()
    df <- as.DataFrame(faithful)
    head(df)
    
  2. Applica il seguente esempio di specifica SparkApplication nel cluster utente:

    apiVersion: "sparkoperator.k8s.io/v1beta2"
    kind: SparkApplication
    metadata:
      name: spark-r-dataframe
      namespace: foo
    spec:
      type: R
      mode: cluster
      image: "${DATAPROC_IMAGE?}"
      imagePullPolicy: Always
      mainApplicationFile: "local:///usr/lib/spark/examples/src/main/r/dataframe.R"
      sparkVersion: "3.1.3"
      restartPolicy:
        type: Never
      driver:
        cores: 1
        coreLimit: "1000m"
        memory: "512m"
        serviceAccount: spark
      executor:
        cores: 1
        instances: 1
        memory: "512m"
    
  3. Verifica che l'esempio di specifica SparkApplication venga eseguito e completato in meno di un minuto utilizzando il seguente comando:

    kubectl --kubeconfig AO_USER_KUBECONFIG get SparkApplication spark-r-dataframe -n foo
    

Visualizza i log di un'applicazione Spark 3

Spark ha i seguenti due tipi di log che puoi visualizzare:

Utilizza il terminale per eseguire i comandi.

Log del driver

Segui questi passaggi per visualizzare i log del driver della tua applicazione Spark:

  1. Trova il pod del driver Spark:

    kubectl -n spark get pods
    
  2. Apri i log dal pod del driver Spark:

    kubectl -n spark logs DRIVER_POD
    

    Sostituisci DRIVER_POD con il nome del pod del driver Spark che hai trovato nel passaggio precedente.

Log eventi

Puoi trovare i log eventi nel percorso specificato nel file YAML della specifica SparkApplication.

Segui questi passaggi per visualizzare i log eventi della tua applicazione Spark:

  1. Apri il file YAML della specifica SparkApplication.
  2. Individua il campo spec nel file.
  3. Individua il campo sparkConf nidificato nel campo spec.
  4. Individua il valore del campo spark.eventLog.dir nidificato nella sezione sparkConf.
  5. Apri il percorso per visualizzare i log eventi.

Per un file YAML di esempio della specifica SparkApplication, consulta Scrivi una specifica dell'applicazione Spark.

Per saperne di più, contatta il tuo account manager.