Executar uma carga de trabalho em lote do Apache Spark

Saiba como usar o Dataproc Serverless para enviar uma carga de trabalho em lote em uma infraestrutura de computação gerenciada pelo Dataproc que escalona os recursos conforme necessário.

Antes de começar

1. Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

2. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

3. Make sure that billing is enabled for your Google Cloud project.

4. Enable the Dataproc API.

   Enable the API

5. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

6. Make sure that billing is enabled for your Google Cloud project.

7. Enable the Dataproc API.

   Enable the API

Enviar uma carga de trabalho em lote do Spark

Console

1. No console do Google Cloud, acesse os lotes do Dataproc. Clique em Criar para abrir a página Criar lote.

2. Selecione e preencha os seguintes campos na página para enviar uma carga de trabalho em lote do Spark que calcula o valor aproximado de pi:

   • Informações do lote:
     • ID do lote: especifique um ID para a carga de trabalho em lote. Esse valor precisa ter de 4 a 63 caracteres em letras minúsculas. Os caracteres válidos são /[a-z][0-9]-/.
     • Região: selecione uma região em que a carga de trabalho será executada.
   • Contêiner:
     • Tipo de lote: Spark.
     • Versão do ambiente de execução: a versão padrão do ambiente de execução é selecionada. Como opção, é possível especificar Versão não padrão do ambiente de execução do Dataproc sem servidor.
     • Classe principal:

       org.apache.spark.examples.SparkPi

     • Arquivos jar, que são pré-instalados no ambiente de execução Spark do Dataproc sem servidor.

       file:///usr/lib/spark/examples/jars/spark-examples.jar

     • Argumentos: 1000.
   • Configuração de execução: é possível especificar uma conta de serviço usar para executar a carga de trabalho. Se você não especificar uma conta de serviço, a carga de trabalho será executada na conta de serviço padrão do Compute Engine.
   • Configuração de rede: a sub-rede da VPC que executa cargas de trabalho do Dataproc Serverless para Spark precisa estar ativada para o Acesso particular do Google e atender aos outros requisitos listados em Configuração de rede do Dataproc Serverless para Spark. A lista de sub-redes exibe sub-redes na rede selecionada que estão ativadas para Acesso privado do Google.
   • Propriedades: insira Key (nome da propriedade) e Value das propriedades do Spark com suporte para definir na carga de trabalho em lote do Spark. Observação: diferentemente do Dataproc no Compute Engine propriedades do cluster, As propriedades de carga de trabalho do Dataproc sem servidor para Spark não incluem um spark:. .
   • Outras opções:
     • É possível configurar a carga de trabalho em lote para usar um metastore do Hive autogerenciado externo.
     • É possível usar um Persistent History Server (PHS). O PHS precisa estar localizado na região em que você executa cargas de trabalho em lote.

3. Clique em ENVIAR para executar a carga de trabalho em lote do Spark.

gcloud

Enviar uma carga de trabalho em lote do Spark para calcular o valor aproximado de pi, execute a seguinte CLI gcloud gcloud dataproc batches submit spark localmente em uma janela de terminal ou Cloud Shell:

gcloud dataproc batches submit spark \
    --region=REGION \
    --jars=file:///usr/lib/spark/examples/jars/spark-examples.jar \
    --class=org.apache.spark.examples.SparkPi \
    -- 1000

Observações:

• REGION: Especifique a região em que a carga de trabalho será executada.
• Sub-rede: A sub-rede VPC que executa o Dataproc sem servidor para cargas de trabalho do Spark precisa ter o Acesso privado do Google ativado e atender aos outros requisitos listados em Dataproc sem servidor para configuração de rede do Spark. Se a sub-rede da rede default para a região especificada no comando gcloud dataproc batches submit não estiver ativada para o Acesso privado do Google, faça uma das seguintes ações:
  • Ative a sub-rede da rede padrão para o Acesso privado do Google na região ou
  • Use a sinalização --subnet=[SUBNET_URI] no comando para especificar uma sub-rede que tenha o Acesso privado do Google ativado. É possível executar o comando gcloud compute networks describe [NETWORK_NAME] para listar os URIs das sub-redes em uma rede.
• --jars:o arquivo JAR de exemplo vem pré-instalado no ambiente de execução do Spark. O argumento de comando 1000 passado para a carga de trabalho SparkPi especifica 1.000 iterações da lógica de estimativa de pi (argumentos de entrada da carga de trabalho são incluída depois de "-- ").
• --properties:é possível adicionar o --properties. sinalização para entrar propriedades do Spark com suporte que você quer que a carga de trabalho em lote do Spark use.
• --deps-bucket:é possível adicionar essa sinalização a especifique um bucket do Cloud Storage em que o Dataproc sem servidor fará o upload das dependências da carga de trabalho. O prefixo URI gs:// do bucket não é obrigatório. é possível especificar o caminho ou o nome do bucket, por exemplo: "mybucketname". O Dataproc Serverless para Spark faz o upload dos arquivos locais para uma pasta /dependencies no bucket antes de executar a carga de trabalho em lote. Observação: essa sinalização será obrigatória se o de referência da carga de trabalho na máquina local.
• --ttl: é possível adicionar a flag --ttl para especificar a duração da vida útil do lote. Quando a carga de trabalho ultrapassar ele será encerrado incondicionalmente sem aguardar o trabalho em andamento para ser concluído. Especifique a duração usando um sufixo s, m, h ou d (segundos, minutos, horas ou dias). O valor mínimo é 10 minutos (10m), e o valor máximo é 14 dias (14d).
  • Lotes de ambiente de execução 1.1 ou 2.0:se --ttl não for especificado. para uma carga de trabalho em lote de ambiente de execução 1.1 ou 2.0, a carga de trabalho pode ser executada até sair naturalmente (ou executada para sempre se não sair).
  • Lotes de execução 2.1 ou mais recentes: se --ttl não for especificado para uma carga de trabalho de lote de execução 2.1 ou mais recente, o padrão será 4h.
• Outras opções:você pode adicionar gcloud dataproc batches submit sinalizações de comando para especificar outras opções de carga de trabalho e propriedades do Spark.
  • Metastore do Hive: o comando a seguir configura uma carga de trabalho em lote para usar uma metastore autogerenciada do Hive externa usando uma configuração padrão do Spark.

    gcloud dataproc batches submit \
        --properties=spark.sql.catalogImplementation=hive,spark.hive.metastore.uris=METASTORE_URI,spark.hive.metastore.warehouse.dir=WAREHOUSE_DIR> \
        other args ...
            

  • Servidor de histórico permanente:
    1. O comando a seguir cria um PHS em um cluster do Dataproc de nó único. O PHS precisa estar localizado na região em que você executa cargas de trabalho em lote, e o bucket-name do Cloud Storage precisa existir.

       gcloud dataproc clusters create PHS_CLUSTER_NAME \
           --region=REGION \
           --single-node \
           --enable-component-gateway \
           --properties=spark:spark.history.fs.logDirectory=gs://bucket-name/phs/*/spark-job-history
                    

    2. Envie uma carga de trabalho em lote, especificando o Persistent History Server em execução.

       gcloud dataproc batches submit spark \
           --region=REGION \
           --jars=file:///usr/lib/spark/examples/jars/spark-examples.jar \
           --class=org.apache.spark.examples.SparkPi \
           --history-server-cluster=projects/project-id/regions/region/clusters/PHS-cluster-name \
           -- 1000
                     

  • Versão do ambiente de execução: Use a sinalização --version para especificar o Dataproc sem servidor do ambiente de execução para a carga de trabalho.

    gcloud dataproc batches submit spark \
        --region=REGION \
        --jars=file:///usr/lib/spark/examples/jars/spark-examples.jar \
        --class=org.apache.spark.examples.SparkPi \
        --version=VERSION
        -- 1000
                

API

Esta seção mostra como criar uma carga de trabalho em lote para calcular o valor aproximado de pi usando o Dataproc Serverless para Spark batches.create.

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

• project-id: um ID do projeto do Google Cloud.
• region: uma região do Compute Engine em que o Dataproc sem servidor vai executar a carga de trabalho.
Observações:
• Imagem-do-contêiner-personalizado: especifique a imagem do contêiner personalizado usando o formato de nomenclatura da imagem do Docker: {hostname}/{project-id}/{image}:{tag}, por exemplo, "gcr.io/my-project-id/my-image:1.0.1". Observação: é necessário hospedar o contêiner personalizado no Container Registry.
• Sub-rede: A sub-rede VPC que executa o Dataproc sem servidor para cargas de trabalho do Spark precisa ter o Acesso privado do Google ativado e atender aos outros requisitos listados em Dataproc sem servidor para configuração de rede do Spark. Se o default sub-rede da rede da região especificada não está ativada para Acesso privado do Google, siga um destes procedimentos:
  1. Ative a sub-rede da rede padrão para o Acesso privado do Google na região ou
  2. Use o ExecutionConfig.subnetworkUri para especificar uma sub-rede que tenha o Acesso privado do Google ativado. É possível executar o comando gcloud compute networks describe [NETWORK_NAME] para listar os URIs das sub-redes em uma rede.
• sparkBatch.jarFileUris: o arquivo jar de exemplo é pré-instaladas no ambiente de execução do Spark. O valor "1000" sparkBatch.args é transmitido para a carga de trabalho do SparkPi e especifica 1.000 iterações da lógica de estimativa de pi.
• Spark properties:use o RuntimeConfig.properties campo para inserir propriedades do Spark com suporte que você quer que a carga de trabalho em lote do Spark use.
• --ttl:use o EnvironmentConfig.ttl para especificar a duração do ciclo de vida do lote. Quando a carga de trabalho ultrapassar ela será encerrada incondicionalmente sem aguardar o trabalho em andamento para ser concluído. Especifique a duração como a representação JSON para Duration. O valor mínimo é de 10 minutos, e o máximo é de 14 dias.
  • Lotes de ambiente de execução 1.1 ou 2.0:se --ttl não for especificado. para uma carga de trabalho em lote de ambiente de execução 1.1 ou 2.0, a carga de trabalho pode ser executada até sair naturalmente (ou executada para sempre se não sair).
  • 2.1+ lotes de execução: se --ttl não for especificado para uma carga de trabalho de lote de execução 2.1 ou mais recente, o padrão será 4 horas.
• Outras opções:
  • Configurar a carga de trabalho em lote para usar externo autogerenciado Metastore do Hive.
  • Use um servidor de histórico permanente (PHS, na sigla em inglês). O PHS precisa estar localizado na região em que você executa cargas de trabalho em lote.
  • Usar o RuntimeConfig.version como parte da solicitação batches.create para especificar um Versão não padrão do ambiente de execução do Dataproc sem servidor
  .

Método HTTP e URL:

POST https://dataproc.googleapis.com/v1/projects/project-id/locations/region/batches

Corpo JSON da solicitação:

{
  "sparkBatch":{
    "args":[
      "1000"
    ],
    "jarFileUris":[
      "file:///usr/lib/spark/examples/jars/spark-examples.jar"
    ],
    "mainClass":"org.apache.spark.examples.SparkPi"
  }
}

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/locations/region/batches"

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/locations/region/batches" | Select-Object -Expand Content

Você receberá uma resposta JSON semelhante a esta:

{
"name":"projects/project-id/locations/region/batches/batch-id",
  "uuid":",uuid",
  "createTime":"2021-07-22T17:03:46.393957Z",
  "sparkBatch":{
    "mainClass":"org.apache.spark.examples.SparkPi",
    "args":[
      "1000"
    ],
    "jarFileUris":[
      "file:///usr/lib/spark/examples/jars/spark-examples.jar"
    ]
  },
  "runtimeInfo":{
    "outputUri":"gs://dataproc-.../driveroutput"
  },
  "state":"SUCCEEDED",
  "stateTime":"2021-07-22T17:06:30.301789Z",
  "creator":"account-email-address",
  "runtimeConfig":{
    "properties":{
      "spark:spark.executor.instances":"2",
      "spark:spark.driver.cores":"2",
      "spark:spark.executor.cores":"2",
      "spark:spark.app.name":"projects/project-id/locations/region/batches/batch-id"
    }
  },
  "environmentConfig":{
    "peripheralsConfig":{
      "sparkHistoryServerConfig":{
      }
    }
  },
  "operation":"projects/project-id/regions/region/operation-id"
}

Como a carga de trabalho calcula Pi: a carga de trabalho do Spark estima um valor de Pi usando o método de Monte Carlo. Ele gera pontos "x,y" em um plano cartesiano que modela um círculo cercado por um quadrado de unidade. O argumento de entrada ("1000") determina o número de pares x,y a serem gerados. Quanto mais pares gerados, maior a precisão da estimativa. Para mais informações, consulte Como estimar o Pi usando o método de Monte Carlo e conferir JavaSparkPi.java no GitHub.

Estimar custos de carga de trabalho

O Dataproc sem servidor para cargas de trabalho do Spark consome a unidade de computação de dados (DCU) e embaralhar os recursos de armazenamento. Para conferir um exemplo que gera UsageMetrics do Dataproc para estimar o consumo de recursos e os custos da carga de trabalho, consulte Preços do Dataproc sem servidor.

A seguir

Saiba mais sobre:

• Cotas do Dataproc sem servidor
• Propriedades do Spark