Usar GPUs

É possível anexar aceleradores de GPU às cargas de trabalho em lote do Serviço Gerenciado para Apache Spark para alcançar os seguintes resultados:

• Acelere o processamento de cargas de trabalho de análise de dados em grande escala.

• Acelere treinamento de modelo em grandes conjuntos de dados usando bibliotecas de machine learning de GPU.

• Realizar análises de dados avançadas, como processamento de vídeo ou linguagem natural.

Todos os runtimes compatíveis do Serviço Gerenciado para Apache Spark adicionam a biblioteca do Spark RAPIDS a cada nó de carga de trabalho. A versão 1.1 do ambiente de execução do Serviço Gerenciado para Apache Spark também adiciona a biblioteca XGBoost aos nós de carga de trabalho. Essas bibliotecas oferecem ferramentas eficientes de transformação de dados e machine learning que podem ser usadas em cargas de trabalho aceleradas por GPU.

Benefícios da GPU

Confira alguns dos benefícios de usar GPUs com suas cargas de trabalho do Serviço Gerenciado para Apache Spark:

• Melhoria de performance:a aceleração de GPU pode aumentar significativamente a performance das cargas de trabalho do Spark, principalmente para tarefas que exigem muita computação, como machine learning e aprendizado profundo, processamento de gráficos e análises complexas.

• Treinamento de treinamento de modelo mais rápido:para tarefas de machine learning, anexar GPUs pode reduzir drasticamente o tempo necessário para treinar modelos, permitindo que cientistas de dados e engenheiros iterem e façam experimentos rapidamente.

• Escalonabilidade:os clientes podem adicionar mais nós de GPU ou GPUs mais potentes aos nós para lidar com necessidades de processamento cada vez mais complexas.

• Eficiência de custo:embora as GPUs exijam um investimento inicial, é possível economizar custos ao longo do tempo devido à redução dos tempos de processamento e ao uso mais eficiente dos recursos.

• Análise de dados avançada:a aceleração de GPU permite realizar análises avançadas, como análise de imagens e vídeos e processamento de linguagem natural, em grandes conjuntos de dados.

• Produtos melhores:o processamento mais rápido permite tomar decisões mais rápidas e ter aplicativos mais responsivos.

Limitações e considerações

• Os aceleradores de GPU estão disponíveis no nível de preços premium.

• É possível anexar GPUs NVIDIA A100 ou NVIDIA L4 a cargas de trabalho em lote do Serviço gerenciado para Apache Spark. Os aceleradores A100 e L4 estão sujeitos à disponibilidade regional de GPUs do Compute Engine.

• A biblioteca XGBoost só é fornecida para cargas de trabalho aceleradas por GPU do Serviço Gerenciado para Apache Spark ao usar a versão 1.x do ambiente de execução do Spark.

• Os jobs em lote acelerados por GPU do Serviço Gerenciado para Apache Spark com XGBoost usam cotas aumentadas do Compute Engine. Por exemplo, para executar uma carga de trabalho em lote sem servidor que usa uma GPU NVIDIA L4, aloque a cota de GPUs NVIDIA_L4.

• Os jobs ativados por acelerador não são compatíveis com a política da organização constraints/compute.requireShieldedVm. Se a organização aplicar essa política, os jobs com aceleração não serão executados corretamente.

• É necessário definir o conjunto de caracteres padrão como UTF-8 ao usar a aceleração de GPU do RAPIDS com runtimes compatíveis do Serviço Gerenciado para Apache Spark antes da versão 2.2. Consulte Criar uma carga de trabalho em lote sem servidor com aceleradores de GPU para mais informações.

Preços

Os aceleradores de GPU estão disponíveis no nível de preços premium. Consulte os preços do Serviço Gerenciado para Apache Spark para informações sobre os preços dos aceleradores.

Antes de começar

Antes de criar uma carga de trabalho em lote sem servidor com aceleradores de GPU anexados, faça o seguinte:

Faça login na sua conta do Google Cloud . Se você começou a usar o Google Cloud, 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.

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

Roles required to select or create a project

• Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
• Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

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

Verify that billing is enabled for your Google Cloud project.

Enable the Dataproc, Compute Engine, and Cloud Storage APIs.

Roles required to enable APIs

To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

Enable the APIs

Instale a CLI do Google Cloud.

Ao usar um provedor de identidade (IdP) externo, primeiro faça login na gcloud CLI com sua identidade federada.

Para inicializar a gcloud CLI, execute o seguinte comando:

gcloud init

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

Roles required to select or create a project

• Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
• Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

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

Verify that billing is enabled for your Google Cloud project.

Enable the Dataproc, Compute Engine, and Cloud Storage APIs.

Roles required to enable APIs

To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

Enable the APIs

Instale a CLI do Google Cloud.

Ao usar um provedor de identidade (IdP) externo, primeiro faça login na gcloud CLI com sua identidade federada.

Para inicializar a gcloud CLI, execute o seguinte comando:

gcloud init

1. No console do Google Cloud , acesse a página Buckets do Cloud Storage.

   Acessar buckets

2. Clique em Criar.
3. Na página Criar um bucket, insira as informações do seu bucket. Para ir à próxima etapa, clique em Continuar.
   1. Na seção Começar, faça o seguinte:
      • Insira um nome globalmente exclusivo que atenda aos requisitos de nomeação de bucket.
      • Para adicionar um rótulo de bucket, abra a seção Rótulos (), clique em Adicionar rótulo e especifique um key e um value para o rótulo.
   2. Na seção Escolha onde armazenar seus dados, faça o seguinte:
      1. Selecione um tipo de local.
      2. Escolha um local onde os dados do bucket são armazenados permanentemente no menu suspenso Tipo de local.
         • Se você selecionar o tipo de local birregional, também poderá ativar a replicação turbo usando a caixa de seleção relevante.
      3. Para configurar a replicação entre buckets, selecione Adicionar replicação entre buckets usando o Serviço de transferência do Cloud Storage e siga estas etapas:

         Configurar a replicação entre buckets

         1. No menu Bucket, selecione um bucket.

         2. Na seção Configurações de replicação, clique em Configurar para definir as configurações do job de replicação.

            O painel Configurar a replicação entre buckets aparece.

            • Para filtrar objetos a serem replicados por prefixo de nome de objeto, insira um prefixo com que você quer incluir ou excluir objetos e clique em Adicionar um prefixo.
            • Para definir uma classe de armazenamento para os objetos replicados, selecione uma classe de armazenamento no menu Classe de armazenamento. Se você pular esta etapa, os objetos replicados vão usar a classe de armazenamento do bucket de destino por padrão.
            • Clique em Concluído.
   3. Na seção Escolha como armazenar seus dados, faça o seguinte:
      1. Selecione uma classe de armazenamento padrão para o bucket ou Classe automática para gerenciamento automático da classe de armazenamento dos dados do bucket.
      2. Para ativar o namespace hierárquico, na seção Otimizar o armazenamento para cargas de trabalho com uso intensivo de dados, selecione Ativar namespace hierárquico neste bucket.
         Observação:não é possível ativar o namespace hierárquico em buckets existentes.
   4. Na seção Escolha como controlar o acesso a objetos, selecione se o bucket aplica ou não a prevenção de acesso público e selecione um método de controle de acesso para os objetos do bucket.
      Observação:não é possível mudar a configuração Impedir acesso público se ela for aplicada em uma política da organização.
   5. Na seção Escolha como proteger os dados do objeto, faça o seguinte:
      • Selecione qualquer uma das opções em Proteção de dados que você quer definir para o bucket.
        • Para ativar a exclusão reversível, clique na caixa de seleção Política de exclusão reversível (para recuperação de dados) e especifique o número de dias que você quer reter os objetos após a exclusão.
        • Para definir o controle de versões de objetos, clique na caixa de seleção Controle de versões de objetos (para controle de versões) e especifique o número máximo de versões por objeto e o número de dias após os quais as versões não atuais expiram.
        • Para ativar a política de retenção em objetos e buckets, clique na caixa de seleção Retenção (para compliance) e faça o seguinte:
          • Para ativar o bloqueio de retenção de objetos, clique na caixa de seleção Ativar retenção de objetos.
          • Para ativar o Bloqueio de buckets, clique na caixa de seleção Definir política de retenção de buckets e escolha uma unidade e um período de armazenamento para a retenção.
      • Para escolher como os dados do objeto serão criptografados, expanda a seção Criptografia de dados () e selecione um método de Criptografia de dados.
4. Clique em Criar.

Criar uma carga de trabalho em lote sem servidor com aceleradores de GPU

Envie uma carga de trabalho em lote do Serviço Gerenciado para Apache Spark que use GPUs NVIDIA L4 para executar uma tarefa paralela do PySpark. Siga estas etapas usando a CLI gcloud:

1. Clique em Expandir e crie e salve o código PySpark listado em um arquivo test-py-spark-gpu.py na máquina local usando um editor de texto ou de código.

   Expandir Fechar

   #!/usr/bin/env python
   
   """S8s Accelerators Example."""
   
   import subprocess
   from typing import Any
   from pyspark.sql import SparkSession
   from pyspark.sql.functions import col
   from pyspark.sql.types import IntegerType
   from pyspark.sql.types import StructField
   from pyspark.sql.types import StructType
   
   spark = SparkSession.builder.appName("joindemo").getOrCreate()
   
   
   def get_num_gpus(_: Any) -> int:
     """Returns the number of GPUs."""
     p_nvidia_smi = subprocess.Popen(
         ["nvidia-smi", "-L"], stdin=None, stdout=subprocess.PIPE
     )
     p_wc = subprocess.Popen(
         ["wc", "-l"],
         stdin=p_nvidia_smi.stdout,
         stdout=subprocess.PIPE,
         stderr=subprocess.PIPE,
         universal_newlines=True,
     )
     [out, _] = p_wc.communicate()
     return int(out)
   
   
   num_workers = 5
   result = (
       spark.sparkContext.range(0, num_workers, 1, num_workers)
       .map(get_num_gpus)
       .collect()
   )
   num_gpus = sum(result)
   print(f"Total accelerators: {num_gpus}")
   
   # Run the join example
   schema = StructType([StructField("value", IntegerType(), True)])
   df = (
       spark.sparkContext.parallelize(range(1, 10000001), 6)
       .map(lambda x: (x,))
       .toDF(schema)
   )
   df2 = (
       spark.sparkContext.parallelize(range(1, 10000001), 6)
       .map(lambda x: (x,))
       .toDF(schema)
   )
   joined_df = (
       df.select(col("value").alias("a"))
       .join(df2.select(col("value").alias("b")), col("a") == col("b"))
       .explain()
   )

2. Use a CLI gcloud na sua máquina local para enviar o job em lote sem servidor do Serviço Gerenciado para Apache Spark com cinco workers, cada um acelerado com GPUs L4:

   gcloud dataproc batches submit pyspark test-py-spark-gpu.py \
       --project=PROJECT_ID \
       --region=REGION \
       --deps-bucket=BUCKET_NAME \
       --version=1.1 \
       --properties=spark.dataproc.executor.compute.tier=premium,spark.dataproc.executor.disk.tier=premium,spark.dataproc.executor.resource.accelerator.type=l4,spark.executor.instances=5,spark.dataproc.driverEnv.LANG=C.UTF-8,spark.executorEnv.LANG=C.UTF-8,spark.shuffle.manager=com.nvidia.spark.rapids.RapidsShuffleManager
   

Observações:

• PROJECT_ID: o ID do projeto do Google Cloud .
• REGION: uma região do Compute Engine disponível para executar a carga de trabalho.
• BUCKET_NAME: o nome do bucket do Cloud Storage. O Spark faz upload das dependências da carga de trabalho para uma pasta /dependencies nesse bucket antes de executar a carga de trabalho em lote.
• --version::todos os ambientes de execução compatíveis do Serviço Gerenciado para Apache Spark adicionam a biblioteca RAPIDS a cada nó de uma carga de trabalho acelerada por GPU. Somente a versão 1.1 do ambiente de execução adiciona a biblioteca XGBoost a cada nó de uma carga de trabalho acelerada por GPU.

• --properties (consulte Propriedades de alocação de recursos do Spark) :

  • spark.dataproc.driverEnv.LANG=C.UTF-8 e spark.executorEnv.LANG=C.UTF-8 (obrigatório com versões de tempo de execução anteriores a 2.2): essas propriedades definem o conjunto de caracteres padrão como C.UTF-8.

  • spark.dataproc.executor.compute.tier=premium (obrigatório): as cargas de trabalho aceleradas por GPU são faturadas usando unidades de computação de dados (DCUs) premium. Consulte os preços dos aceleradores do Serviço Gerenciado para Apache Spark.

  • spark.dataproc.executor.disk.tier=premium (obrigatório): os nós com aceleradores A100-40, A100-80 ou L4 precisam usar o nível de disco premium.

  • spark.dataproc.executor.resource.accelerator.type=l4 (obrigatório): apenas um tipo de GPU precisa ser especificado. O job de exemplo seleciona a GPU L4. Os seguintes tipos de acelerador podem ser especificados com os seguintes nomes de argumentos:

    Tipo de GPU	Nome do argumento
    A100 40 GB	a100-40
    A100 80 GB	a100-80

  • spark.executor.instances=5 (obrigatório): é necessário indicar, pelo menos, dois. Defina como cinco para este exemplo.

  • spark.executor.cores (opcional): defina essa propriedade para especificar o número de vCPUs principais. Os valores válidos para GPUs L4 são 4 (padrão) ou 8, 12, 16, 24, 48 ou 96. O único valor válido e padrão para GPUs A100 é 12. As configurações com GPUs L4 e núcleos 24, 48 ou 96 têm GPUs 2, 4 ou 8 anexadas a cada executor. Todas as outras configurações têm uma GPU 1 anexada.

  • spark.dataproc.executor.disk.size (obrigatório): as GPUs L4 têm um tamanho de disco fixo de 375 GB, exceto para configurações com núcleos 24, 48 ou 96, que têm 750, 1,500 ou 3,000 GB, respectivamente. Se você definir essa propriedade com um valor diferente ao enviar uma carga de trabalho acelerada por L4, um erro vai ocorrer. Se você selecionar uma GPU A100 40 ou A100 80, os tamanhos válidos serão 375g, 750g, 1500g, 3000g, 6000g e 9000g.

  • spark.executor.memory (opcional) e spark.executor.memoryOverhead (restrito): é possível definir a memória, mas não memoryOverhead. A quantidade de memória disponível não consumida pela propriedade definida é aplicada à propriedade não definida. spark.executor.memoryOverhead é definido como 40% da memória disponível para cargas de trabalho em lote do PySpark e 10% para outras cargas de trabalho. Consulte Propriedades de alocação de recursos do Spark.

    A tabela a seguir mostra a quantidade máxima de memória que pode ser definida para diferentes configurações de GPU A100 e L4. O valor mínimo para qualquer uma das propriedades é 1024 MB.

    	A100 (40 GB)	A100 (80 GB)	L4 (4 núcleos)	L4 (8 núcleos)	L4 (12 núcleos)	L4 (16 núcleos)	L4 (24 núcleos)	L4 (48 núcleos)	L4 (96 núcleos)
    Memória total máxima (MB)	78040	165080	13384	26768	40152	53536	113072	160608	321216

  • Propriedades do Spark RAPIDS (opcional): por padrão, o Serviço Gerenciado para Apache Spark define os seguintes valores de propriedade do Spark RAPIDS:

    • spark.plugins=com.nvidia.spark.SQLPlugin
    • spark.executor.resource.gpu.amount=1
    • spark.task.resource.gpu.amount=1/$spark_executor_cores
    • spark.shuffle.manager=''. Por padrão, essa propriedade não é definida. A NVIDIA recomenda ativar o gerenciador de embaralhamento RAPIDS ao usar GPUs para melhorar a performance. Para fazer isso, defina spark.shuffle.manager=com.nvidia.spark.rapids.RapidsShuffleManager ao enviar uma carga de trabalho.
    • spark.rapids.sql.concurrentGpuTasks= mínimo de (gpuMemoryinMB / 8, 4)
    • spark.rapids.shuffle.multiThreaded.writer.threads= mínimo de (núcleos de CPU na VM / contagem de GPUs por VM, 32)
    • spark.rapids.shuffle.multiThreaded.reader.threads= mínimo de (núcleos de CPU na VM / contagem de GPUs por VM, 32)

    Consulte Configuração do acelerador RAPIDS para Apache Spark para definir propriedades do Spark RAPIDS e Configuração avançada do acelerador RAPIDS para Apache Spark para definir propriedades avançadas do Spark.