Executar uma carga de trabalho em lote do Apache Spark

Saiba como usar o Serverless para Apache Spark e enviar uma carga de trabalho em lote em uma infraestrutura de computação gerenciada pelo Dataproc que escalona 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.

    Go to project selector

  3. Verify 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.

    Go to project selector

  6. Verify that billing is enabled for your Google Cloud project.

  7. Enable the Dataproc API.

    Enable the API

    8.

    Enviar uma carga de trabalho em lote do Spark

    É possível usar o console Google Cloud , a Google Cloud CLI ou a API Serverless para Apache Spark para criar e enviar uma carga de trabalho em lote do Serverless para Apache Spark.

    Console

    1. No console 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:

    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 seguinte comando da CLI gcloud gcloud dataproc batches submit spark 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 sua 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.
      • --version: É possível especificar uma versão do ambiente de execução do Serverless para Apache Spark não padrão.
      • --jars: O arquivo JAR de exemplo é pré-instalado no ambiente de execução do Spark. O argumento de comando 1000 transmitido à carga de trabalho SparkPi especifica 1.000 iterações da lógica de estimativa de pi. Os argumentos de entrada da carga de trabalho são incluídos após "-- ".
      • --subnet: Adicione 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 Serverless para Apache Spark vai selecionar a sub-rede default na região da sessão. O Serverless para Apache Spark ativa o Acesso privado do Google (PGA) na sub-rede. Para requisitos de conectividade de rede, consulte Google Cloud Configuração de rede do Serverless para Apache Spark.
      • --properties: é possível adicionar essa flag para inserir propriedades do Spark compatíveis para uso na carga de trabalho em lote do Spark.
      • --deps-bucket: é possível adicionar essa flag para especificar um bucket do Cloud Storage em que o Serverless para Apache Spark vai fazer upload das dependências da carga de trabalho. O prefixo de URI gs:// do bucket não é obrigatório. É possível especificar o caminho ou o nome do bucket. O Serverless para Apache Spark faz 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 referenciar arquivos na máquina local.
      • --ttl: é possível adicionar a flag --ttl para especificar a duração do ciclo de vida 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 em lote de execução 1.1 ou 2.0, ela poderá ser executada até sair naturalmente (ou para sempre, se não sair).
        • Lotes de ambiente de execução 2.1 ou mais recentes:se --ttl não for especificado para uma carga de trabalho em lote do ambiente 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 sua 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 um metastore do Hive autogerenciado externo 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 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 as 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 Serverless para Apache Spark da 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

    Nesta seção, mostramos como criar uma carga de trabalho em lote para calcular o valor aproximado de pi usando o Serverless para Apache 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 Google Cloud Serverless para Apache Spark vai executar a carga de trabalho.

      • Observações:

      • PROJECT_ID: o ID do projeto do Google Cloud . Os IDs do projeto estão listados na seção Informações do projeto no painel do console 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:

    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":{
    "version":"2.3",
    "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"
}

    Estimar custos de carga de trabalho

    As cargas de trabalho sem servidor para Apache Spark consomem unidades de computação de dados (DCUs) e recursos de armazenamento de embaralhamento. Para um exemplo que gera UsageMetrics do Dataproc para estimar o consumo de recursos e os custos da carga de trabalho, consulte Preços do Serverless para Apache Spark.

    A seguir

    Saiba mais sobre: