Esta página foi traduzida pela API Cloud Translation.

Executar um job do Spark no Dataproc no Google Kubernetes Engine

Antes de começar

Você precisa ter criado um cluster padrão (não do Autopilot) do Google Kubernetes Engine (GKE) regional ou zonal com a Identidade da carga de trabalho ativada.
Dica de desempenho:ative o streaming de imagens para inicializar a carga de trabalho mais rapidamente.

Criar um cluster virtual do Dataproc no GKE

Um cluster virtual do Dataproc no GKE é criado como a plataforma de implantação para componentes do Dataproc. É um recurso virtual e, ao contrário de um cluster do Dataproc no Compute Engine, não inclui VMs mestre e worker do Dataproc separadas.

O Dataproc no GKE cria pools de nós em um cluster do GKE quando você cria um cluster virtual do Dataproc no GKE.
Os jobs do Dataproc no GKE são executados como pods nesses pools de nós. Os pools de nós e a programação de pods nos pools de nós são gerenciados pelo GKE.
Crie vários clusters virtuais. É possível criar e executar vários clusters virtuais em um cluster do GKE para melhorar a utilização de recursos compartilhando pools de nós entre os clusters virtuais.
- Cada cluster virtual:
  - é criado com propriedades separadas, incluindo a versão do mecanismo Spark e a identidade da carga de trabalho
  - é isolado em um namespace do GKE separado no cluster do GKE

Console

No console do Google Cloud, acesse a página Clusters do Dataproc.

Acessar Clusters
Clique em Criar cluster.
Na caixa de diálogo Criar cluster do Dataproc, clique em Criar na linha Cluster no GKE.
No painel Configurar cluster:
1. No campo Nome do cluster, insira um nome para o cluster.
2. Na lista Região, selecione uma região para o cluster virtual do Dataproc no GKE. Essa região precisa ser a mesma em que seu cluster do GKE está localizado (selecionada no próximo item).
3. No campo Kubernetes Cluster, clique em Browse para selecionar a região em que seu cluster do GKE está localizado.
4. Opcional: no campo Bucket de preparação do Cloud Storage, clique em Procurar para selecionar um bucket do Cloud Storage. O Dataproc no GKE vai preparar os artefatos no bucket. Ignore esse campo para que o Dataproc no GKE crie um bucket de preparação.
No painel à esquerda, clique em Configurar pools de nós e, no painel Pools de nós, clique em Adicionar um pool.
1. Para reutilizar um pool de nós do Dataproc no GKE:
  1. Clique em Reutilizar o pool de nós atual.
  2. Insira o nome do pool de nós e selecione a função dele. Pelo menos um pool de nós precisa ter o papel DEFAULT.
  3. Clique em Concluído.
2. Para criar um novo pool de nós do Dataproc no GKE:
  1. Clique em Criar um novo pool de nós.
  2. Insira os seguintes valores do pool de nós:
    - Nome do pool de nós
    - Função: pelo menos um pool de nós precisa ter a função DEFAULT.
    - Local: especifique uma zona na região do cluster do Dataproc no GKE.
    - Tipo de máquina do pool de nós
    - Plataforma de CPU
    - Preemptibilidade
    - Mín.: contagem mínima de nós.
    - Máximo: contagem máxima de nós. A contagem máxima de nós precisa ser maior que 0.
3. Clique em Adicionar um pool para adicionar mais pools de nós. Todos os pools de nós precisam ter o local. É possível adicionar um total de quatro pools de nós.
(Opcional) Se você tiver configurado um servidor de histórico persistente do Dataproc (PHS) para usar o histórico de jobs do Spark em clusters ativos e excluídos do Dataproc no GKE, clique em Personalizar cluster. Em seguida, no campo Cluster do servidor de histórico, procure e escolha o cluster PHS. O cluster do PHS precisa estar localizado na mesma região do cluster virtual do Dataproc no GKE.
Clique em Criar para gerar o cluster do Dataproc. O cluster do Dataproc no GKE aparece em uma lista na página Clusters. O status é Provisionamento até que o cluster esteja pronto para uso. Depois disso, o status muda para Em execução.

gcloud

Defina variáveis de ambiente e execute o comando gcloud dataproc clusters gke create localmente ou no Cloud Shell para criar um cluster do Dataproc no GKE.

Defina as variáveis de ambiente:
```
DP_CLUSTER=Dataproc on GKE  cluster-name \
  REGION=region \
  GKE_CLUSTER=GKE cluster-name \
  BUCKET=Cloud Storage bucket-name \
  DP_POOLNAME=node pool-name
  PHS_CLUSTER=Dataproc PHS server name
```
Observações:
- DP_CLUSTER: defina o nome do cluster virtual do Dataproc, que precisa começar com uma letra minúscula seguida de até 54 letras minúsculas, números ou hifens. Ele não pode terminar com um hífen.
- REGION: o region precisa ser o mesmo que a região em que o cluster do GKE está localizado.
- GKE_CLUSTER: o nome do cluster do GKE.
- BUCKET: (opcional) especifique o nome de um bucket do Cloud Storage, que o Dataproc vai usar para preparar artefatos. Se você não especificar um bucket, o Dataproc no GKE vai criar um bucket de preparo.
- DP_POOLNAME: o nome de um pool de nós a ser criado no cluster do GKE.
- PHS_CLUSTER: (opcional) Servidor de PHS do Dataproc para conferir o histórico de jobs do Spark em clusters do Dataproc ativos e excluídos no GKE. O cluster do PHS precisa estar localizado na mesma região do cluster virtual do Dataproc no GKE.
Execute o comando:
```
gcloud dataproc clusters gke create ${DP_CLUSTER} \
    --region=${REGION} \
    --gke-cluster=${GKE_CLUSTER} \
    --spark-engine-version=latest \
    --staging-bucket=${BUCKET} \
    --pools="name=${DP_POOLNAME},roles=default" \
    --setup-workload-identity \
    --history-server-cluster=${PHS_CLUSTER}
```
Observações:
- --spark-engine-version: a versão da imagem do Spark usada no cluster do Dataproc. É possível usar um identificador, como 3, 3.1 ou latest, ou especificar a versão completa da submenor, como 3.1-dataproc-5.
- --staging-bucket: exclua essa flag para que o Dataproc no GKE crie um bucket de preparo.
- --pools: essa flag é usada para especificar um pool de nós novo ou existente que o Dataproc vai criar ou usar para executar a carga de trabalho. Liste as configurações do pool de nós do Dataproc no GKE, separadas por vírgulas, por exemplo:
```
--pools=name=dp-default,roles=default,machineType=e2-standard-4,min=0,max=10
```
  É preciso especificar o name e o role do pool de nós. Outras configurações do pool de nós são opcionais. É possível usar várias flags --pools para especificar vários pools de nós. Pelo menos um pool de nós precisa ter o papel default. Todos os pools de nós precisam ter o mesmo local.
- --setup-workload-identity: essa flag ativa as vinculações da Identidade da carga de trabalho. Essas vinculações permitem que as contas de serviço do Kubernetes (KSAs, na sigla em inglês) atuem como a conta de serviço de VM do Dataproc (identidade do plano de dados) padrão do cluster virtual.
  Você precisa de permissões elevadas para definir a identidade da carga de trabalho em uma conta de serviço do Google (GSA). Consulte Permissões do IAM do Dataproc no Google Kubernetes Engine. Para usar sua própria GSA com o Dataproc no cluster virtual do GKE, consulte Configuração personalizada do IAM.

REST

Conclua um virtualClusterConfig como parte de uma solicitação cluster.create da API Dataproc.

Antes de usar os dados da solicitação abaixo, faça as substituições a seguir:

PROJECT: ID do projeto do Google Cloud
REGION: região do cluster virtual do Dataproc (mesma região do cluster do GKE)
DP_CLUSTER: nome do cluster do Dataproc
GKE_CLUSTER: nome do cluster do GKE
NODE_POOL: nome do pool de nós
PHS_CLUSTER: nome do cluster do servidor de histórico persistente (PHS, na sigla em inglês)
BUCKET: (opcional) nome do bucket de preparação. Deixe esse campo em branco para que o Dataproc no GKE crie um bucket de transferência.

Método HTTP e URL:

POST https://dataproc.googleapis.com/v1/projects/project-id/regions/region/clusters

Corpo JSON da solicitação:

{
  "clusterName":"DP_CLUSTER",
  "projectId":"PROJECT",
  "virtualClusterConfig":{
    "auxiliaryServicesConfig":{
      "sparkHistoryServerConfig":{
        "dataprocCluster":"projects/PROJECT/regions/REGION/clusters/PHS_CLUSTER"
      }
    },
    "kubernetesClusterConfig":{
      "gkeClusterConfig":{
        "gkeClusterTarget":"projects/PROJECT/locations/REGION/clusters/GKE_CLUSTER",
        "nodePoolTarget":[
          {
"nodePool":"projects/PROJECT/locations/REGION/clusters/GKE_CLUSTER/nodePools/NODE_POOL",
            "roles":[
              "DEFAULT"
            ]
          }
        ]
      },
      "kubernetesSoftwareConfig":{
        "componentVersion":{
          "SPARK":"latest"
        }
      }
    },
    "stagingBucket":"BUCKET"
  }
}

Para enviar a solicitação, expanda uma destas opções:

curl (Linux, macOS ou Cloud Shell)

Observação: o comando a seguir pressupõe que você fez login na CLI gcloud com sua conta de usuário executando gcloud init ou gcloud auth login, ou usando o Cloud Shell, que faz login automaticamente na CLI gcloud. . É possível verificar a conta ativa atual executando gcloud auth list.

Salve o corpo da solicitação em um arquivo com o nome request.json e execute o comando a seguir:

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/regions/region/clusters"

PowerShell (Windows)

Observação: o comando a seguir pressupõe que você fez login na CLI gcloud com sua conta de usuário executando gcloud init ou gcloud auth login . É possível verificar a conta ativa atual executando gcloud auth list.

Salve o corpo da solicitação em um arquivo com o nome request.json e execute o comando a seguir:

$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/regions/region/clusters" | Select-Object -Expand Content

Você receberá uma resposta JSON semelhante a esta:

{
  "projectId":"PROJECT",
  "clusterName":"DP_CLUSTER",
  "status":{
    "state":"RUNNING",
    "stateStartTime":"2022-04-01T19:16:39.865716Z"
  },
  "clusterUuid":"98060b77-...",
  "statusHistory":[
    {
      "state":"CREATING",
      "stateStartTime":"2022-04-01T19:14:27.340544Z"
    }
  ],
  "labels":{
    "goog-dataproc-cluster-name":"DP_CLUSTER",
    "goog-dataproc-cluster-uuid":"98060b77-...",
    "goog-dataproc-location":"REGION",
    "goog-dataproc-environment":"prod"
  },
  "virtualClusterConfig":{
    "stagingBucket":"BUCKET",
    "kubernetesClusterConfig":{
      "kubernetesNamespace":"dp-cluster",
      "gkeClusterConfig":{
"gkeClusterTarget":"projects/PROJECT/locations/REGION/clusters/GKE_CLUSTER",
        "nodePoolTarget":[
          {
"nodePool":"projects/PROJECT/locations/REGION/clusters/GKE_CLUSTER/nodePools/NODE_POOL",
            "roles":[
              "DEFAULT"
            ]
          }
        ]
      },
      "kubernetesSoftwareConfig":{
        "componentVersion":{
          "SPARK":"3.1-..."
        },
        "properties":{
          "dpgke:dpgke.unstable.outputOnly.endpoints.sparkHistoryServer":"https://...",
          "spark:spark.eventLog.dir":"gs://BUCKET/.../spark-job-history",
          "spark:spark.eventLog.enabled":"true"
        }
      }
    },
    "auxiliaryServicesConfig":{
      "sparkHistoryServerConfig":{
        "dataprocCluster":"projects/PROJECT/regions/REGION/clusters/PHS_CLUSTER"
      }
    }
  }

Enviar um job do Spark

Depois que o cluster virtual do Dataproc no GKE estiver em execução, envie um job do Spark usando o console do Google Cloud, a CLI do gcloud ou a API jobs.submit do Dataproc (usando solicitações HTTP diretas ou as bibliotecas de cliente do Cloud).

Exemplo de job do Spark da CLI gcloud:

gcloud dataproc jobs submit spark \
    --region=${REGION} \
    --cluster=${DP_CLUSTER} \
    --class=org.apache.spark.examples.SparkPi \
    --jars=local:///usr/lib/spark/examples/jars/spark-examples.jar \
    -- 1000

Exemplo de job do PySpark da gcloud CLI:

gcloud dataproc jobs submit pyspark \
    --region=${REGION} \
    --cluster=${DP_CLUSTER} \
    local:///usr/lib/spark/examples/src/main/python/pi.py \
    -- 10

Exemplo de job do SparkR da CLI gcloud:

gcloud dataproc jobs submit spark-r \
    --region=${REGION} \
    --cluster=${DP_CLUSTER} \
    local:///usr/lib/spark/examples/src/main/r/dataframe.R

Limpar

Exclua os recursos a seguir usados neste guia de início rápido que você não quer continuar usando.
Exclua o cluster do Dataproc no GKE.
Exclua os pools de nós usados pelo cluster do Dataproc no GKE.
Excluir o cluster do GKE.