Executar uma carga de trabalho em lote do Apache Spark

Saiba como usar o Dataproc sem servidor 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. Faça login na sua conta do Google Cloud. Se você começou a usar o Google Cloud agora, crie uma conta para avaliar o desempenho de nossos produtos em situações reais. Clientes novos também recebem US$ 300 em créditos para executar, testar e implantar cargas de trabalho.
  2. No console do Google Cloud, na página do seletor de projetos, selecione ou crie um projeto do Google Cloud.

    Acessar o seletor de projetos

  3. Verifique se a cobrança está ativada para o seu projeto do Google Cloud.

  4. Ative a API Dataproc.

    Ative a API

  5. No console do Google Cloud, na página do seletor de projetos, selecione ou crie um projeto do Google Cloud.

    Acessar o seletor de projetos

  6. Verifique se a cobrança está ativada para o seu projeto do Google Cloud.

  7. Ative a API Dataproc.

    Ative a API

Enviar uma carga de trabalho em lote do Spark

Console

  1. No console do Google Cloud, acesse 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 minúsculos. 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 foi selecionada. Opcionalmente, você pode especificar uma versão não padrão do ambiente de execução sem servidor do Dataproc.
      • Classe principal:
        org.apache.spark.examples.SparkPi
      • Arquivos jar (esse arquivo é pré-instalado no ambiente de execução do Dataproc sem servidor do 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.
    • Configuração de rede: a sub-rede VPC que executa cargas de trabalho do Dataproc sem servidor para Spark precisa estar ativada para o Acesso privado do Google e atender aos outros requisitos listados em Configuração de rede do Dataproc sem servidor para Spark. A lista de sub-redes exibe as sub-redes na rede selecionada que estão ativadas para o Acesso privado do Google.
    • Propriedades: insira o Key (nome da propriedade) e o Value das propriedades do Spark com suporte para definir na carga de trabalho em lote do Spark. Observação: diferentemente das propriedades de cluster do Dataproc no Compute Engine, as propriedades de carga de trabalho do Dataproc sem servidor para Spark não incluem um prefixo spark:.
    • Outras opções:
  3. 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 gcloud a seguir localmente em uma janela do 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

Observações:

  • REGION: Especifique a região em que a carga de trabalho será executada.
  • Sub-rede: a sub-rede VPC que executa cargas de trabalho do Dataproc sem servidor para Spark precisa ser ativada para o Acesso privado do Google e atender aos outros requisitos listados em Configuração de rede do Dataproc sem servidor para 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, siga um destes procedimentos:
    • Ativar a sub-rede da rede padrão para a região para Acesso privado do Google ou
    • Use a sinalização --subnet=[SUBNET_URI] no comando para especificar uma sub-rede com o Acesso privado do Google ativado. Execute o comando gcloud compute networks describe [NETWORK_NAME] para listar os URIs das sub-redes em uma rede.
  • --jars: o arquivo JAR de exemplo está pré-instalado no ambiente de execução do Spark. O argumento do comando 1000 passado para a carga de trabalho do 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 "-- ").
  • --properties: adicione a sinalização --properties para inserir propriedades do Spark com suporte que você quer que sua carga de trabalho em lote do Spark use.
  • --deps-bucket: adicione esta sinalização para especificar um bucket do Cloud Storage em que o Dataproc sem servidor fará upload das dependências de carga de trabalho. O prefixo de URI gs:// do bucket não é necessário. Você pode especificar o caminho ou o nome do bucket, por exemplo, "mybucketname". O Dataproc sem servidor 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 a carga de trabalho em lote fizer referência a arquivos na máquina local.
  • --ttl: adicione a sinalização --ttl para especificar a duração da vida útil do lote. Quando a carga de trabalho excede essa duração, ela é encerrada incondicionalmente sem esperar a conclusão do trabalho em andamento. 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 valor máximo é de 14 dias (14d).
    • Lotes do ambiente de execução 1.1 ou 2.0:se --ttl não for especificado para uma carga de trabalho em lote do ambiente de execução 1.1 ou 2.0, a carga de trabalho poderá ser executada até sair naturalmente (ou ser executada 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 posterior, o padrão será 4h.
  • Outras opções: é possível adicionar flags de comando gcloud dataproc batches submit 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 um Metastore Hive autogerenciado externo com 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 a versão do ambiente de execução sem servidor do Dataproc 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

Nesta seção, mostramos como criar uma carga de trabalho em lote para calcular o valor aproximado de pi usando o Dataproc sem servidor para Spark batches.create`

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

  • project-id: ID do projeto do Google Cloud.
  • region: uma região do Compute Engine em que o Dataproc sem servidor executará a carga de trabalho.
  • Observações:
    • Custom-container-image::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:é preciso hospedar seu contêiner personalizado no Container Registry.
    • Sub-rede: a sub-rede VPC que executa cargas de trabalho do Dataproc sem servidor para Spark precisa ser ativada para o Acesso privado do Google e atender aos outros requisitos listados em Configuração de rede sem servidor do Dataproc para Spark. Se a sub-rede da rede default para a região especificada não estiver ativada para o Acesso privado do Google, siga um destes procedimentos:
      1. Ativar a sub-rede da rede padrão para a região para Acesso privado do Google ou
      2. Use o campo ExecutionConfig.subnetworkUri para especificar uma sub-rede com o Acesso privado do Google ativado. Execute 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 está pré-instalado no ambiente de execução do Spark. O sparkBatch.args "1000" é 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 campo RuntimeConfig.properties para inserir as propriedades do Spark com suporte que serão usadas pela carga de trabalho em lote do Spark.
    • --ttl: use o campo EnvironmentConfig.ttl para especificar a duração da vida útil do lote. Quando a carga de trabalho excede essa duração, ela é encerrada incondicionalmente sem esperar a conclusão do trabalho em andamento. Especifique a duração como a representação JSON de Duration. O valor mínimo é de 10 minutos, e o máximo é de 14 dias.
      • Lotes do ambiente de execução 1.1 ou 2.0:se --ttl não for especificado para uma carga de trabalho em lote do ambiente de execução 1.1 ou 2.0, a carga de trabalho poderá ser executada até sair naturalmente (ou ser executada 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 posterior, o padrão será de quatro horas.
    • Outras opções:

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

Estime os custos da carga de trabalho

O Dataproc sem servidor para cargas de trabalho do Spark consomem os recursos de armazenamento da unidade de computação de dados (DCU, na sigla em inglês) e embaralhar. Para ver um exemplo que gera UsageMetrics do Dataproc para estimar o consumo e os custos dos recursos da carga de trabalho, consulte Preços do Dataproc sem servidor .

A seguir

Saiba mais sobre: