Executar uma carga de trabalho em lote do Apache Spark

Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.

Console

1. No console do Google Cloud, acesse os lotes do Dataproc.

2. Clique em Criar.

3. Envie uma carga de trabalho em lote do Spark que calcula o valor aproximado de pi selecionando e preenchendo os seguintes campos:

   • 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. Você pode especificar uma versão de ambiente de execução não padrão do Dataproc sem servidor.
     • Classe principal:

       org.apache.spark.examples.SparkPi

     • Arquivos JAR: esse arquivo é pré-instalado no ambiente de execução do Dataproc sem servidor para Spark.

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

     • Argumentos: 1000.
   • Configuração de execução:é possível especificar uma conta de serviço 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. Sua conta de serviço precisa ter a função de worker do Dataproc.
   • Configuração de rede:selecione uma sub-rede na região da sessão. O Dataproc Serverless ativa o Acesso particular do Google (PGA, na sigla em inglês) na sub-rede especificada. Para requisitos de conectividade de rede, consulte Configuração de rede do Dataproc sem servidor para Spark.
   • 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: ao contrário do Dataproc nas propriedades de cluster do Compute Engine, as propriedades de carga de trabalho do Dataproc Serverless para Spark não incluem um prefixo spark:.
   • Outras opções:
     • É possível configurar a carga de trabalho em lote para usar um Metastore do Hive autogerenciado externo.
     • Você pode usar um servidor de histórico persistente (PHS). O PHS precisa estar localizado na região em que você executa cargas de trabalho em lote.

4. Clique em Enviar para executar a carga de trabalho em lote do Spark.

gcloud

Para enviar uma carga de trabalho em lote do Spark para calcular o valor aproximado de pi, execute o comando gcloud dataproc batches submit spark da CLI do gcloud localmente em uma janela de terminal ou no 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

Substitua:

• REGION: Especifique a região em que a carga de trabalho será executada.
• Outras opções:é possível adicionar flags gcloud dataproc batches submit spark para especificar outras opções de carga de trabalho e propriedades do Spark.
  • --jars: o arquivo JAR de exemplo é pré-instalado no ambiente de execução do Spark. O argumento de comando 1000 transmitido para a carga de trabalho do SparkPi especifica 1.000 iterações da lógica de estimativa de pi. Os argumentos de entrada de carga de trabalho são incluídos após o "-- ".
  • --subnet: é possível adicionar essa flag para especificar o nome de uma sub-rede na região da sessão. Se você não especificar uma sub-rede, o Dataproc Serverless vai selecionar a sub-rede default na região da sessão. O Dataproc Serverless ativa o Acesso particular do Google (PGA, na sigla em inglês) na sub-rede. Para requisitos de conectividade de rede, consulte Configuração de rede do Dataproc Serverless para Spark.
  • --properties: é possível adicionar essa flag para inserir propriedades do Spark com suporte para que sua carga de trabalho em lote do Spark seja usada.
  • --deps-bucket: é possível adicionar essa flag para especificar um bucket do Cloud Storage em que o Dataproc Serverless vai fazer upload das dependências de carga de trabalho. O prefixo URI gs:// do bucket não é necessário. É possível especificar o caminho ou o nome do bucket. 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 flag é obrigatória se a carga de trabalho em lote referencia arquivos na máquina local.
  • --ttl: é possível adicionar a flag --ttl para especificar a duração do lote. Quando a carga de trabalho excede essa duração, ela é encerrada incondicionalmente sem esperar que o trabalho em andamento seja concluído. Especifique a duração usando um sufixo s, m, h ou d (segundos, minutos, horas ou dias). O valor mínimo é de 10 minutos (10m), e o máximo é de 14 dias (14d).
    • Lotes de execução 1.1 ou 2.0:se --ttl não for especificado para uma carga de trabalho de lote de execução 1.1 ou 2.0, ela poderá ser executada até que seja encerrada naturalmente (ou será executada para sempre, se não for encerrada).
    • 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.
  • --service-account: É possível especificar uma conta de serviço 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. Sua conta de serviço precisa ter o papel de worker do Dataproc.
  • 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 spark\
        --properties=spark.sql.catalogImplementation=hive,spark.hive.metastore.uris=METASTORE_URI,spark.hive.metastore.warehouse.dir=WAREHOUSE_DIR> \
        other args ...
            

  • Servidor de histórico persistente:
    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 servidor de histórico permanente 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 flag --version para especificar a versão do ambiente de execução do Dataproc sem servidor 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 Google Cloud .
• region: uma região do Compute Engine em que o Dataproc sem servidor vai executar a carga de trabalho.

Observações:

• PROJECT_ID: o ID do projeto do Google Cloud . Os IDs dos projetos estão listados na seção Informações do projeto no Painel do console do Google Cloud.
• REGION: a região da sessão.

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

$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"
}