Esta página foi traduzida pela API Cloud Translation.

Contentor do Dataproc para o Spark

O Google Distributed Cloud (GDC) air-gapped fornece um contentor Dataproc para o Spark. Trata-se de um ambiente Apache Spark para o tratamento de dados. Para mais informações sobre o Apache Spark, consulte https://spark.apache.org/. Use contentores do Dataproc Container for Spark para executar aplicações Spark novas ou existentes num cluster do Kubernetes da Distributed Cloud com alterações mínimas. Se estiver familiarizado com as ferramentas do Spark, pode continuar a usá-las.

Defina a sua aplicação Spark num ficheiro YAML e o Distributed Cloud atribui os recursos por si. O contentor do Dataproc para o contentor do Spark é iniciado em segundos. Os executores do Spark são dimensionados ou encerrados de acordo com as suas necessidades.

Configure contentores do Dataproc Container for Spark na Distributed Cloud para usar hardware especializado, como nós de hardware especializados ou GPUs.

Implemente o contentor do Dataproc para o serviço Spark

O administrador da plataforma (PA) tem de instalar os serviços do Marketplace para si antes de poder usar os serviços. Contacte o seu PA se precisar do Dataproc Container para o Spark. Consulte o artigo Instale um pacote de software do GDC Marketplace para mais informações.

Pré-requisitos para executar aplicações Spark

Tem de ter uma conta de serviço em clusters de utilizadores para usar o serviço Dataproc Container for Spark. O contentor Dataproc para o Spark cria um pod de controlador do Spark para executar uma aplicação Spark. Um pod de controlador do Spark precisa de uma conta de serviço do Kubernetes no espaço de nomes do pod com autorizações para realizar as seguintes ações:

Criar, obter, listar e eliminar pods de executor.
Crie um serviço sem cabeça do Kubernetes para o controlador.

Antes de executar uma aplicação Spark, conclua os passos seguintes para garantir que tem uma conta de serviço com as autorizações anteriores no espaço de nomes foo:

Crie uma conta de serviço para um pod de controlador do Spark para usar no foo namespace:
```
kubectl create serviceaccount spark --kubeconfig AO_USER_KUBECONFIG --namespace=foo
```
Nota: o espaço de nomes foo corresponde ao espaço de nomes do projeto foo.
Crie uma função para conceder autorizações para criar, obter, listar e eliminar pods de executor e crie um serviço sem cabeça do Kubernetes para o controlador no espaço de nomes foo:
```
kubectl create role spark-driver --kubeconfig AO_USER_KUBECONFIG --verb=* \
--resource=pods,services,configmaps,persistentvolumeclaims \
--namespace=foo
```

Crie uma associação de funções para conceder acesso à função de conta de serviço no espaço de nomes foo:

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

Execute aplicações de exemplo do Spark 3

A contentorização de aplicações Spark simplifica a execução de aplicações de grande volume de dados nas suas instalações através do Distributed Cloud. Como operador de aplicações (AO), execute aplicações Spark especificadas em objetos do GKE do tipo de recurso personalizado SparkApplication.

Para executar e usar uma aplicação Apache Spark 3 no Distributed Cloud, conclua os seguintes passos:

Examine a spark-operator imagem no seu projeto para encontrar o $DATAPROC_IMAGE a que vai fazer referência na sua aplicação 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/')

Por exemplo:

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

Escreva uma SparkApplicationespecificação e armazene-a num ficheiro YAML. Para mais informações, consulte a secção Escreva uma especificação da aplicação Spark.
Envie, execute e monitorize a sua aplicação Spark conforme configurada numa SparkApplication especificação no cluster do GKE com o comando kubectl. Para mais informações, consulte a secção Exemplos de aplicação.
Reveja o estado da candidatura.
Opcional: reveja os registos da aplicação. Para mais informações, consulte a secção Veja os registos de uma aplicação Spark 3.
Use a aplicação Spark para recolher e apresentar o estado do controlador e dos executores ao utilizador.

Escreva uma especificação da aplicação Spark

Uma especificação SparkApplication inclui os seguintes componentes:

O campo apiVersion.
O campo kind.
O campo metadata.
A secção spec.

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

Exemplos de aplicação

Esta secção inclui os seguintes exemplos com as respetivas especificações SparkApplication para executar aplicações Spark:

Spark Pi
Spark SQL
Spark MLlib
SparkR

Spark Pi

Esta secção contém um exemplo para executar uma aplicação Spark Pi com utilização intensiva de computação que estima 𝛑 (pi) ao atirar dardos num círculo.

Siga os passos seguintes para executar o Spark Pi:

Aplique o seguinte exemplo de especificação SparkApplication no cluster de utilizadores:

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"

Verifique se o exemplo de especificação SparkApplication é executado e concluído em 1 a 2 minutos através do seguinte comando:
```
kubectl --kubeconfig AO_USER_KUBECONFIG get SparkApplication spark-pi -n foo
```

Veja os registos do condutor para ver o resultado:

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

Um resultado é semelhante ao seguinte:

Pi is roughly 3.1407357036785184

Para obter mais informações, consulte os seguintes recursos:

Para o código da aplicação, consulte o artigo Pi estimation da documentação do Apache Spark: https://spark.apache.org/examples.html.
Para ver um ficheiro YAML de exemplo do Spark Pi, consulte o artigo Escreva uma especificação da aplicação Spark.

Spark SQL

Siga os passos seguintes para executar o Spark SQL:

Para executar uma aplicação Spark SQL que selecione o valor 1, use a seguinte consulta:
```
select 1;
```

Aplique o seguinte SparkApplication exemplo de especificação no cluster de utilizadores:

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"

Valide se o exemplo de especificação SparkApplication é executado e concluído em menos de um minuto através do seguinte comando:
```
kubectl --kubeconfig AO_USER_KUBECONFIG get SparkApplication pyspark-sql-arrow -n foo
```

Spark MLlib

Siga os passos abaixo para executar o Spark MLlib:

Use o exemplo de Scala seguinte para executar uma instância do Spark MLlib que realiza análise estatística e imprime um resultado na consola:

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")

Aplique o seguinte exemplo de especificação SparkApplication no cluster de utilizadores:

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"

Valide se o exemplo de especificação SparkApplication é executado e concluído em menos de um minuto através do seguinte comando:
```
kubectl --kubeconfig AO_USER_KUBECONFIG get SparkApplication spark-ml -n foo
```

SparkR

Siga os passos seguintes para executar o SparkR:

Use o seguinte exemplo de código para executar uma instância do SparkR que carrega um conjunto de dados incluído e imprime a primeira linha:
```
library(SparkR)
sparkR.session()
df <- as.DataFrame(faithful)
head(df)
```

Aplique o seguinte SparkApplication exemplo de especificação no cluster de utilizadores:

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"

Valide se o exemplo de especificação SparkApplication é executado e concluído em menos de um minuto através do seguinte comando:
```
kubectl --kubeconfig AO_USER_KUBECONFIG get SparkApplication spark-r-dataframe -n foo
```

Veja os registos de uma aplicação Spark 3

O Spark tem os dois seguintes tipos de registos que pode visualizar:

Registos do condutor
Registos de eventos

Use o terminal para executar comandos.

Registos do condutor

Siga os passos seguintes para ver os registos do controlador da sua aplicação Spark:

Encontre o pod do controlador do Spark:
```
kubectl -n spark get pods
```
Abra os registos do pod do controlador do Spark:
```
kubectl -n spark logs DRIVER_POD
```
Substitua DRIVER_POD pelo nome do pod do controlador do Spark que encontrou no passo anterior.

Registos de eventos

Pode encontrar os registos de eventos no caminho especificado no ficheiro YAML da especificação SparkApplication.

Siga os passos seguintes para ver os registos de eventos da sua aplicação Spark:

Abra o ficheiro YAML da SparkApplicationespecificação.
Localize o campo spec no ficheiro.
Localize o campo sparkConf aninhado no campo spec.
Localize o valor do campo spark.eventLog.dir aninhado na secção sparkConf.
Abra o caminho para ver os registos de eventos.

Para ver um ficheiro YAML de exemplo da especificação SparkApplication, consulte o artigo Escreva uma especificação da aplicação Spark.

Contacte o seu gestor de conta para obter mais informações.