Executar um job do Spark no Dataproc no Google Kubernetes Engine

Antes de começar

  1. Você precisa ter criado um cluster padrão (não automático) de zona ou regional do Google Kubernetes Engine (GKE) com a Identidade da carga de trabalho ativada no cluster.

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. Ele é um recurso virtual e, ao contrário de um cluster legado do Dataproc no Compute Engine, não inclui VMs separadas do mestre e do worker do Dataproc. Em vez disso, o Dataproc no GKE cria pools de nós em um cluster do GKE quando você cria um Dataproc no cluster virtual do 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.

  • Criar 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 diferentes, incluindo a versão do mecanismo Spark e a identidade da carga de trabalho, e é isolado em um namespace separado do GKE no cluster do GKE. A exclusão de um ou mais Dataproc nos clusters do GKE não exclui os pools de nós associados. Os pools de nós são excluídos quando o cluster do GKE é excluído. Consulte Exclusão do pool de nós.

Console

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

    Acessar Clusters

  2. Clique em Criar cluster.

  3. Na caixa de diálogo Criar cluster do Dataproc, clique em Criar na linha Cluster no GKE.

  4. No painel Configurar cluster:

    1. No campo Nome do cluster, insira um nome para ele.
    2. Na lista Região, selecione uma região para o cluster virtual do Dataproc no GKE. Precisa ser a mesma região em que o cluster do GKE está localizado, que será selecionado no próximo item.
    3. No campo Cluster do Kubernetes, clique em Procurar para selecionar a região em que o cluster atual do GKE está localizado.
    4. (Opcional) No campo Bucket de preparo do Cloud Storage, clique em Procurar para selecionar um bucket atual do Cloud Storage que o Dataproc no GKE usará para preparar artefatos. Ignore este campo para que o Dataproc no GKE crie um bucket de preparo.
  5. No painel esquerdo, clique em Configurar pools de nós e, no painel Pools de nós, clique em Adicionar um pool.

    1. Para reutilizar um Dataproc atual no pool de nós do GKE:
      1. Clique em Reutilizar pool de nós atual.
      2. Insira o nome do pool de nós atual e selecione o papel. Pelo menos um pool de nós precisa ter o papel PADRÃO.
      3. Clique em Concluir.
    2. Para criar um novo Dataproc no pool de nós do GKE:
      1. Clique em Criar um novo pool de nós.
      2. Insira os valores do nome do pool de nós, papel, local (zona dentro da região do cluster do Dataproc na GKE), tipo de máquina, plataforma de CPU, previsibilidade, min (contagem mínima de nós) e máx. (contagem máxima de nós). A contagem máxima de nós precisa ser maior que 0, e pelo menos um pool de nós precisa ter o papel PADRÃO.
    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.
  6. (Opcional) Se você tiver configurado um Servidor de histórico permanente (PHS, na sigla em inglês) do Dataproc para usar para visualizar o histórico de jobs do Spark em clusters ativos e excluídos do Dataproc em clusters do GKE, clique em Personalizar cluster e, no campo Cluster de servidor de histórico, procure e escolha o cluster do PHS. O cluster do PHS precisa estar localizado na mesma região do Dataproc no cluster virtual do GKE.

  7. Clique em Criar para gerar o cluster do Dataproc. Seu cluster do Dataproc no GKE aparece em uma lista na página Clusters. O status dele será Provisioning até que o cluster esteja pronto para uso. Em seguida, o status mudará para Running.

gcloud

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

  1. 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 por até 54 letras minúsculas, números ou hifens. Ele não pode terminar com hífen.
    • REGIÃO: o region precisa ser igual à região em que o cluster do GKE está localizado.
    • GKE_CLUSTER: o nome do cluster atual do GKE.
    • BUCKET: (opcional) é possível especificar o nome de um bucket do Cloud Storage que o Dataproc usará para organizar artefatos. Se você não especificar um bucket, o Dataproc no GKE 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 PHS do Dataproc a ser usado para visualizar o histórico de job do Spark no Dataproc ativo e excluído nos clusters do GKE. O cluster do PHS precisa estar localizado na mesma região do cluster virtual do Dataproc no GKE.
  2. 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 menor, como 3.1-dataproc-5.
    • --staging-bucket: exclua essa sinalização para que o Dataproc no GKE crie um bucket de preparo.
    • --pools: essa sinalização é usada para especificar um pool de nós novo ou atual que o Dataproc criará ou usará para executar a carga de trabalho. Liste as configurações do pool de nós no Dataproc, separadas por vírgulas, por exemplo, --pools=name=dp-default,roles=default,machineType=e2-standard-4,min=0,max=10. É preciso especificar o pool de nós name e role. As outras configurações são opcionais. É possível usar várias sinalizações pools para especificar vários pools de nós, mas pelo menos uma pesquisa de nó precisa ter o papel default e todos os pools de nós precisam ter o mesmo local.
    • --setup-workload-identity: essa sinalização ativa as vinculações de Identidade da carga de trabalho, que permitem que as contas de serviço do Kubernetes (KSAs) atuem como a conta de serviço da VM do Dataproc (identidade do plano de dados) do cluster virtual.

REST e linha de comando

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

Antes de usar qualquer um dos dados da solicitação, faça as seguintes substituições:

  • PROJECT: ID do projeto do Google Cloud
  • REGION: região do cluster virtual do Dataproc (mesma região da região atual 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 Persistent History Server (PHS)
  • BUCKET: (opcional) nome do bucket de preparo. Deixe este campo vazio para que o Dataproc no GKE crie um bucket de preparo.

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:

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 (por meio de solicitações HTTP diretas ou das Bibliotecas de cliente do Cloud).

Exemplo de job da CLI do gcloud na CLI:

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 para a CLI do gcloud:

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

Exemplo de job da CLI CLI do gcloud:

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

Limpar