Contêiner do Dataproc para Spark

O Google Distributed Cloud (GDC) com isolamento físico oferece um contêiner do Dataproc para Spark. Esse é um ambiente do Apache Spark para processamento de dados. Para mais informações sobre o Apache Spark, consulte https://spark.apache.org/. Use contêineres do Dataproc Container para Spark para executar aplicativos Spark novos ou atuais em um cluster do Kubernetes do Distributed Cloud com alterações mínimas. Se você já conhece as ferramentas do Spark, pode continuar usando.

Defina seu aplicativo Spark em um arquivo YAML, e o Distributed Cloud aloca os recursos para você. O contêiner do Dataproc para Spark é iniciado em segundos. Os executores do Spark escalonar verticalmente ou desligados de acordo com suas necessidades.

Configure contêineres do Dataproc Container para Spark no Distributed Cloud para usar hardware especializado, como nós de hardware especializados ou GPUs.

Implante o serviço de contêiner do Dataproc para Spark

O administrador da plataforma (PA, na sigla em inglês) precisa instalar os serviços do Marketplace para você antes que você possa usá-los. Entre em contato com seu PA se precisar do contêiner do Dataproc para Spark. Consulte Instalar um pacote de software do GDC Marketplace para mais informações.

Pré-requisitos para executar aplicativos Spark

Você precisa ter uma conta de serviço em clusters de usuários para usar o serviço do contêiner do Dataproc para Spark. O contêiner do Dataproc para Spark cria um pod de driver do Spark para executar um aplicativo Spark. Um pod de driver do Spark precisa de uma conta de serviço do Kubernetes no namespace do pod com permissões para realizar as seguintes ações:

• Criar, receber, listar e excluir pods executores.
• Crie um serviço headless do Kubernetes para o driver.

Antes de executar um aplicativo Spark, siga estas etapas para garantir que você tenha uma conta de serviço com as permissões anteriores no namespace foo:

1. Crie uma conta de serviço para um pod de driver do Spark usar no namespace foo:

   kubectl create serviceaccount spark --kubeconfig AO_USER_KUBECONFIG --namespace=foo
   

   Observação: o namespace foo corresponde ao namespace do projeto foo.

2. Crie uma função para conceder permissões de criação, recebimento, listagem e exclusão de pods executores e crie um serviço headless do Kubernetes para o driver no namespace foo:

   kubectl create role spark-driver --kubeconfig AO_USER_KUBECONFIG --verb=* \
   --resource=pods,services,configmaps,persistentvolumeclaims \
   --namespace=foo
   

3. Crie uma vinculação de papel para conceder acesso ao papel da conta de serviço no namespace foo:

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

Cuidado: mais tarde, ao criar recursos personalizados SparkApplication e ScheduledSparkApplication no namespace foo, especifique a conta de serviço no campo .spec.driver.serviceAccount do arquivo YAML. Para ver um exemplo de arquivo YAML da especificação SparkApplication, consulte Escrever uma especificação de aplicativo Spark.

Executar aplicativos de exemplo do Spark 3

A contêinerização de aplicativos Spark simplifica a execução de aplicativos de Big Data nas suas instalações usando o Distributed Cloud. Como um operador de aplicativos (AO), execute aplicativos do Spark especificados em objetos do GKE do tipo de recurso personalizado SparkApplication.

Para executar e usar um aplicativo do Apache Spark 3 na Distributed Cloud, siga estas etapas:

1. Examine a imagem spark-operator no projeto para encontrar o $DATAPROC_IMAGE a ser referenciado no aplicativo 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/')
   

   Exemplo:

   export DATAPROC_IMAGE=10.200.8.2:10443/dataproc-service/private-cloud-devel/dataproc:3.1-dataproc-17
   

2. Grave uma especificação SparkApplication e armazene-a em um arquivo YAML. Para mais informações, consulte a seção Escrever uma especificação de aplicativo Spark.

3. Envie, execute e monitore seu aplicativo Spark conforme configurado em uma especificação SparkApplication no cluster do GKE com o comando kubectl. Para mais informações, consulte a seção Exemplos de aplicativos.

4. Analise o status da inscrição.

5. Opcional: revise os registros do aplicativo. Para mais informações, consulte a seção Ver os registros de um aplicativo do Spark 3.

6. Use o aplicativo Spark para coletar e mostrar o status do driver e dos executores ao usuário.

Escrever uma especificação de aplicativo do Spark

Uma especificação SparkApplication inclui os seguintes componentes:

• O campo apiVersion.
• O campo kind.
• O campo metadata.
• Seção spec.

Para mais informações, consulte o Writing a SparkApplication Spec no GitHub: https://github.com/kubeflow/spark-operator/blob/gh-pages/docs/user-guide.md#writing-a-sparkapplication-spec

Exemplos de aplicação

Esta seção inclui os seguintes exemplos com as especificações SparkApplication correspondentes para executar aplicativos Spark:

• Spark Pi
• Spark SQL
• Spark MLlib
• SparkR

Spark Pi

Esta seção contém um exemplo para executar um aplicativo Spark Pi com uso intenso de computação que estima 𝛑 (pi) jogando dardos em um círculo.

Siga estas etapas para executar o Spark Pi:

1. Aplique o seguinte exemplo de especificação SparkApplication no cluster de usuário:

   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. Verifique se o exemplo de especificação SparkApplication é executado e concluído em 1 a 2 minutos usando o seguinte comando:

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

3. Confira os Registros do driver para ver o resultado:

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

   Uma saída é semelhante a esta:

   Pi is roughly 3.1407357036785184
   

Para saber mais, acesse os recursos a seguir:

• Para o código do aplicativo, consulte o artigo Estimativa de Pi na documentação do Apache Spark: https://spark.apache.org/examples.html.
• Para um exemplo de arquivo YAML do Spark Pi, consulte Escrever uma especificação de aplicativo Spark.

Spark SQL

Siga estas etapas para executar o Spark SQL:

1. Para executar um aplicativo Spark SQL que seleciona o valor 1, use a seguinte consulta:

   select 1;
   

2. Aplique o seguinte exemplo de especificação SparkApplication no cluster de usuário:

   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. Verifique se o exemplo de especificação SparkApplication é executado e concluído em menos de um minuto usando o seguinte comando:

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

Spark MLlib

Siga estas etapas para executar o Spark MLlib:

1. Use o exemplo em Scala a seguir para executar uma instância do Spark MLlib que realiza análise estatística e imprime um resultado no 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. Aplique o seguinte exemplo de especificação SparkApplication no cluster de usuário:

   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. Verifique se o exemplo de especificação SparkApplication é executado e concluído em menos de um minuto usando o seguinte comando:

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

SparkR

Siga estas etapas para executar o SparkR:

1. Use o exemplo de código a seguir para executar uma instância do SparkR que carrega um conjunto de dados agrupado e imprime a primeira linha:

   library(SparkR)
   sparkR.session()
   df <- as.DataFrame(faithful)
   head(df)
   

2. Aplique o seguinte exemplo de especificação SparkApplication no cluster de usuário:

   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. Verifique se o exemplo de especificação SparkApplication é executado e concluído em menos de um minuto usando o seguinte comando:

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

Acessar os registros de um aplicativo do Spark 3

O Spark tem os dois tipos de registros a seguir que podem ser visualizados:

• Registros de driver
• Registros de eventos

Use o terminal para executar comandos.

Registros do motorista

Siga estas etapas para ver os registros de driver do seu aplicativo Spark:

1. Encontre o pod do driver do Spark:

   kubectl -n spark get pods
   

2. Abra os registros do pod do driver do Spark:

   kubectl -n spark logs DRIVER_POD
   

   Substitua DRIVER_POD pelo nome do pod de driver do Spark que você encontrou na etapa anterior.

Logs de eventos

Os registros de eventos podem ser encontrados no caminho especificado no arquivo YAML da especificação SparkApplication.

Siga estas etapas para conferir os registros de eventos do seu aplicativo Spark:

1. Abra o arquivo YAML da especificação SparkApplication.
2. Localize o campo spec no arquivo.
3. Localize o campo sparkConf aninhado no campo spec.
4. Localize o valor do campo spark.eventLog.dir aninhado na seção sparkConf.
5. Abra o caminho para ver os registros de eventos.

Para ver um exemplo de arquivo YAML da especificação SparkApplication, consulte Escrever uma especificação de aplicativo Spark.

Entre em contato com seu gerente de contas para mais informações.