Usar o Lightning Engine

O Lightning Engine é a próxima geração de desempenho do Apache Spark, apresentando melhorias exclusivas projetadas para oferecer melhorias substanciais em desempenho, custo-benefício e estabilidade operacional.

Benefícios

Os benefícios do Lightning Engine incluem o seguinte:

• Operações de dados aceleradas: consiga ganhos significativos de desempenho e economia de custos com otimizações na interação do Cloud Storage, incluindo tratamento de metadados, cargas de trabalho de gravação e E/S vetorizada.

• Execução de consultas inteligentes: aproveite as melhorias avançadas do otimizador que reduzem dinamicamente os dados verificados, otimizam o processamento de dados e geram planos de execução mais eficientes para consultas mais rápidas e econômicas.

• Cargas de trabalho de IA e ML simplificadas: reduza os tempos de inicialização do cluster para cargas de trabalho baseadas em GPU e simplifique a implantação em ambientes seguros usando imagens otimizadas para IA.

Embora o Lightning Engine ofereça ganhos substanciais de desempenho, o impacto específico varia de acordo com a carga de trabalho. Ele é mais adequado para tarefas com uso intenso de computação que aproveitam as APIs do Spark Dataframe, as APIs do Spark Dataset e as consultas do Spark SQL, em vez de operações vinculadas a E/S.

Comparação com o mecanismo padrão

O Lightning Engine é uma alternativa ao mecanismo padrão usado para executar jobs do Spark em um cluster do Serviço Gerenciado para Apache Spark. A tabela a seguir compara o Lightning Engine com as propriedades de ativação do mecanismo padrão, a aplicabilidade da carga de trabalho e os principais benefícios.

Recurso	Mecanismo padrão	Lightning Engine
Sinalização da CLI	--engine=default ou desmarque a sinalização	--engine=lightning
Ideal para	Jobs de uso geral, desenvolvimento e testes	Cargas de trabalho de nível empresarial que exigem aceleração significativa
Principais benefícios	Desempenho de referência	Interação otimizada do Cloud Storage, execução de consultas inteligentes

Requisitos

Os seguintes requisitos se aplicam ao recurso Lightning Engine:

• Versão da imagem: o Lightning Engine precisa ser usado com a versão de imagem 2.3.3 do Serviço Gerenciado para Apache Spark e versões de imagem secundárias 2.3 mais recentes. O Lightning Engine não é compatível com a versão de imagem 3.0 do Serviço Gerenciado para Apache Spark.
• Jobs compatíveis: Spark, PySpark, SparkSQL e SparkR são compatíveis. O mecanismo padrão é executado em outros tipos de job enviados a um cluster do Lightning Engine.

Execução de consulta nativa

A execução de consulta nativa (NQE, na sigla em inglês) é um componente opcional do Lightning Engine que oferece um nível mais profundo de aceleração para jobs específicos. É um mecanismo nativo baseado no Apache Gluten e no Velox, otimizado para hardware do Google, que aumenta o desempenho executando partes de uma consulta do Spark fora da JVM.

A NQE é recomendada para:

Tarefas com uso intenso de computação que aproveitam as APIs do Spark Dataframe e as APIs do Spark Dataset, além de consultas do Spark SQL que leem dados de arquivos Parquet e ORC. O formato do arquivo de saída não afeta a performance.

A NQE não é recomendada para:

Jobs que dependem muito de conjuntos de dados distribuídos resilientes (RDDs), funções definidas pelo usuário (UDFs), a maioria das bibliotecas de machine learning (ML) do Spark e operações vinculadas a E/S com atrasos devido ao acesso ao armazenamento.

Requisitos

Os seguintes requisitos se aplicam ao recurso de execução de consulta nativa:

• Mecanismo de execução: a NQE está disponível apenas em clusters ativados com o Lightning Engine na criação do cluster.

• Sistema operacional: apenas os sistemas operacionais Debian-12 e Ubuntu-22 são compatíveis. Os jobs ativados para NQE que usam qualquer outro SO vão falhar.

• Jobs compatíveis: Spark, PySpark, SparkSQL e SparkR são compatíveis. O mecanismo padrão será executado (sem NQE) em outros tipos de job enviados a um cluster do Lightning Engine.

• Tipos de máquina: apenas famílias de máquinas que usam processadores Intel ou AMD são compatíveis. Os jobs ativados para NQE que usam processadores ARM vão falhar (mas podem se beneficiar do Lightning Engine sem NQE).

• Sem GPUs e aceleradores: os jobs ativados para NQE enviados em aceleradores de GPU vão falhar (mas podem se beneficiar do Lightning Engine sem NQE).

• Tipos de dados: as entradas dos seguintes tipos de dados não são compatíveis:

  • Byte: ORC e Parquet
  • Struct, Array, Map: Parquet

Preços

Para informações sobre preços, consulte Preços do Serviço Gerenciado para Apache Spark.

Criar um cluster do Lightning Engine

Esta seção mostra como criar um cluster do Serviço Gerenciado para Apache Spark que ativa o Lightning Engine em jobs do Spark enviados ao cluster.

Também é possível ativar a execução de consulta nativa (NQE) no cluster ao criá-lo ou ativar a NQE mais tarde para jobs específicos do Spark enviados ao cluster.

Antes de começar

Faça login na sua Google Cloud conta do. Se você é novo no Google Cloud, crie uma conta para avaliar a performance dos nossos produtos em cenários 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 you have the permissions required to complete this guide.

Verify that billing is enabled for your Google Cloud project.

Enable the Dataproc API.

Roles required to enable APIs

To enable APIs, you need the serviceusage.services.enable permission. If you created the project, then you likely already have this permission through the Owner role (roles/owner). Otherwise, you can get this permission through the Service Usage Admin role (roles/serviceusage.serviceUsageAdmin). Learn how to grant roles.

Enable the API

Instale a Google Cloud CLI.

Observação: se você já tiver instalado a CLI gcloud anteriormente, verifique se você tem a versão mais recente executando gcloud components update.

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

Para inicializar a CLI gcloud, 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 you have the permissions required to complete this guide.

Verify that billing is enabled for your Google Cloud project.

Enable the Dataproc API.

Roles required to enable APIs

To enable APIs, you need the serviceusage.services.enable permission. If you created the project, then you likely already have this permission through the Owner role (roles/owner). Otherwise, you can get this permission through the Service Usage Admin role (roles/serviceusage.serviceUsageAdmin). Learn how to grant roles.

Enable the API

Instale a Google Cloud CLI.

Observação: se você já tiver instalado a CLI gcloud anteriormente, verifique se você tem a versão mais recente executando gcloud components update.

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

Para inicializar a CLI gcloud, execute o seguinte comando:

gcloud init

Funções exigidas

Alguns papéis do IAM são necessários para criar um cluster do Serviço Gerenciado para Apache Spark e enviar jobs ao cluster. Dependendo das políticas da organização, um proprietário do projeto na nuvem ou um administrador de serviços já pode ter concedido esses papéis a você ou a uma conta de serviço. Para verificar as concessões de papéis, consulte Você precisa conceder papéis?.

Para mais informações sobre a concessão de papéis, consulte Gerenciar o acesso a projetos, pastas e organizações.

Funções do usuário

Para receber as permissões necessárias para criar um cluster do Serviço Gerenciado para Apache Spark, peça ao administrador para conceder a você os seguintes papéis do IAM:

• Todos:
  • Editor do Dataproc (roles/dataproc.editor) no projeto
  • Usuário da conta de serviço (roles/iam.serviceAccountUser) na conta de serviço padrão do Compute Engine

Papel da conta de serviço

Para garantir que a conta de serviço padrão do Compute Engine tenha as permissões necessárias para criar um cluster do Serviço Gerenciado para Apache Spark, peça ao administrador para conceder o papel do IAM de Worker do Dataproc (roles/dataproc.worker) à conta de serviço padrão do Compute Engine no projeto.

Importante: conceda esse papel à conta de serviço padrão do Compute Engine, não à sua conta de usuário. Se o papel não for concedido ao principal correto, poderão ocorrer erros de permissão.

Crie o cluster

Os exemplos a seguir mostram como criar um cluster do Lightning Engine usando o Google Cloud console, a Google Cloud CLI, a API Dataproc, as bibliotecas de cliente do Cloud para Python ou o Terraform. Também é possível criar um cluster com o Lightning Engine ativado usando as bibliotecas de cliente do Cloud para Go, Java, e Node.js.

Console

1. Abra a página **Criar cluster**.
2. Clique em Configuração adicional para expandir essa seção.
3. Edite Personalização e outros.
4. No painel que é aberto, confirme se a caixa de seleção Ativar o Lightning Engine está marcada.
5. Opcional: para ativar o ambiente de execução nativo por padrão para jobs do Spark, marque a caixa de seleção Ativar execução nativa.
6. Clique em Salvar.
7. Defina outras configurações do cluster, conforme necessário.
8. Clique em Criar cluster.

CLI gcloud

1. Para criar um cluster com o Lightning Engine ativado, execute o gcloud dataproc clusters create comando com a --engine=lightning sinalização. Para mais informações, consulte criar um cluster com a CLI gcloud.

   gcloud dataproc clusters create CLUSTER_NAME \
       --region=REGION \
       --engine=lightning \
       --image-version=2.3
   

2. Opcional: para ativar o ambiente de execução nativo por padrão para jobs do Spark, inclua a propriedade spark:spark.dataproc.lightningEngine.runtime=native.

   gcloud dataproc clusters create CLUSTER_NAME \
       --region=REGION \
       --engine=lightning \
       --image-version=2.3 \
       --properties='spark:spark.dataproc.lightningEngine.runtime=native'
   

API

Para criar um cluster com o Lightning Engine ativado, envie uma solicitação clusters.create. Para mais informações, consulte Criar um cluster com a API REST.

1. No corpo da solicitação, defina o engine campo como LIGHTNING.

   {
     "projectId": "PROJECT_ID",
     "clusterName": "CLUSTER_NAME",
     "config": {
       "engine": "LIGHTNING",
       "gceClusterConfig": {},
       "softwareConfig": {
         "imageVersion": "2.3"
       }
     }
   }
   

2. Opcional: para ativar o ambiente de execução nativo por padrão para todos os jobs, inclua a propriedade spark:spark.dataproc.lightningEngine.runtime.

   {
     "projectId": "PROJECT_ID",
     "clusterName": "CLUSTER_NAME",
     "config": {
       "engine": "LIGHTNING",
       "gceClusterConfig": {},
       "softwareConfig": {
         "imageVersion": "2.3",
         "properties": {
           "spark:spark.dataproc.lightningEngine.runtime": "native"
         }
       }
     }
   }
   

Python

1. Para criar um cluster com o Lightning Engine ativado, use o método create_cluster e defina o campo engine na configuração do cluster como LIGHTNING. Para mais informações, consulte criar um cluster com Python.

   from google.cloud import dataproc_v1
   
   def create_lightning_cluster(project_id, region, cluster_name):
       client_options = {"api_endpoint": f"{region}-dataproc.googleapis.com:443"}
       cluster_client = dataproc_v1.ClusterControllerClient(client_options=client_options)
   
       cluster = {
           "project_id": project_id,
           "cluster_name": cluster_name,
           "config": {
               "engine": "LIGHTNING",
               "software_config": {
                   "image_version": "2.3-debian12",
               },
           }
       }
   
       operation = cluster_client.create_cluster(
           project_id=project_id,
           region=region,
           cluster=cluster
       )
       result = operation.result()
       print(f"Cluster created successfully: {result.cluster_name}")
   

2. Opcional: para ativar o ambiente de execução nativo por padrão para jobs do Spark, inclua a propriedade spark:spark.dataproc.lightningEngine.runtime.

   from google.cloud import dataproc_v1
   
   def create_lightning_native_cluster(project_id, region, cluster_name):
       client_options = {"api_endpoint": f"{region}-dataproc.googleapis.com:443"}
       cluster_client = dataproc_v1.ClusterControllerClient(client_options=client_options)
   
       cluster = {
           "project_id": project_id,
           "cluster_name": cluster_name,
           "config": {
               "engine": "LIGHTNING",
               "software_config": {
                   "image_version": "2.3-debian12",
                   "properties": {
                       "spark:spark.dataproc.lightningEngine.runtime": "native"
                   }
               }
           }
       }
   
       operation = cluster_client.create_cluster(
           project_id=project_id,
           region=region,
           cluster=cluster
       )
       result = operation.result()
       print(f"Cluster created successfully: {result.cluster_name}")
   

Terraform

1. Na configuração do recurso google_dataproc_cluster, defina o argumento engine como LIGHTNING.
2. Para mais detalhes e opções avançadas, consulte a documentação oficial do Terraform para o google_dataproc_cluster recurso.

Verificar o mecanismo do cluster

Console

1. Noconsole, acesse a página Detalhes do cluster. Google Cloud
2. Verifique se o valor Lightning Engine está listado no campo Mecanismo.
3. Se você ativou a execução de consulta nativa, verifique se native está listado no campo Execução nativa.

gcloud

1. Para verificar o mecanismo e a NQE (se ativada), execute o comando gcloud dataproc clusters describe:

   gcloud dataproc clusters describe CLUSTER_NAME --project=PROJECT_ID --region=REGION
   

2. Verifique a saída das propriedades engine e lightningEngine.runtime:

   clusterName: lightning-engine-cluster
   engine: lightningEngine
   lightningEngine.runtime: native
   

Enviar um job com o Lightning Engine

Se você ativou o Lightning Engine ao criar um cluster, quando você envia um job do Spark para o cluster, o Lightning Engine é ativado por padrão no job.

Ativar a execução de consulta nativa para um job

Se você ativou a execução de consulta nativa (NQE) ao criar um cluster do Lightning Engine , todos os jobs do Spark serão executados com a NQE ativada, a menos que você desative a NQE em um job específico.

Se você não ativou a NQE ao criar o cluster do Lightning Engine, é possível ativar a NQE para um job ao enviá-lo, conforme mostrado nos exemplos a seguir.

gcloud

Para ativar a execução de consulta nativa ao enviar um job do Spark , inclua a propriedade spark.dataproc.lightningEngine.runtime=native:

gcloud dataproc jobs submit spark \
    --cluster=CLUSTER_NAME \
    --region=REGION \
    --properties=spark.dataproc.lightningEngine.runtime=native \
    -- ...

API

Para ativar a execução de consulta nativa ao enviar um job do Spark, inclua a propriedade spark.dataproc.lightningEngine.runtime na sua solicitação:

{
  "job":{
    "placement":{
      "clusterName": ...
    },
    "sparkJob":{
      "mainClass": ...,
      "properties":{
         "spark.dataproc.lightningEngine.runtime":"native"
      }
    }
  }
}

Desativar a execução de consulta nativa para um job

Se você ativou a execução de consulta nativa (NQE) ao criar um cluster do Lightning Engine, todos os jobs do Spark serão executados com a NQE ativada, a menos que você desative a NQE em um job específico.

É possível desativar a NQE para um job específico do Spark ao enviá-lo, conforme mostrado nos exemplos a seguir.

gcloud

Para desativar a execução de consulta nativa ao enviar um job do Spark para um cluster do Lightning Engine, inclua a spark.dataproc.lightningEngine.runtime=default propriedade:

gcloud dataproc jobs submit spark \
    --cluster=CLUSTER_NAME \
    --region=REGION \
    --properties=spark.dataproc.lightningEngine.runtime=default \
    -- ...

API

Para desativar a execução de consulta nativa ao enviar um job do Spark para um cluster do Lightning Engine, inclua a spark.dataproc.lightningEngine.runtime=default propriedade:

{
  "job":{
    "placement":{
      "clusterName": ...
    },
    "sparkJob":{
      "mainClass": ...,
      "properties":{
         "spark.dataproc.lightningEngine.runtime":"default"
      }
    }
  }
}

Verificar a execução de consulta nativa para um job

Depois de enviar um job para um cluster do Lightning Engine, é possível verificar se a execução de consulta nativa está ativada para o job.

Console

1. No Google Cloud console, acesse a página Jobs.
2. Clique no ID do job para abrir a página Detalhes do job.
3. Verifique se native está listado no campo Execução nativa.

gcloud

1. Execute o comando gcloud dataproc jobs describe:

   gcloud dataproc jobs describe JOB_ID --project=PROJECT_ID --region=REGION
   

2. Verifique a saída de lightningEngine.runtime na seção Propriedades:

   lightningEngine.runtime: native
   

Parâmetros de configuração

A tabela a seguir resume os principais parâmetros de configuração para o Lightning Engine e a execução de consulta nativa.

Nome do parâmetro	Descrição	Mecanismos aplicáveis	Valor padrão	Valor padrão (Lightning Engine)	Substituível pelo usuário (nível do job)	Escopo
--engine	Configuração no nível do cluster para selecionar o mecanismo durante a criação do cluster.	Em todo o cluster	default	lightning	Não	Cluster
spark:spark.dataproc.lightningEngine.runtime	Configuração no nível do cluster para selecionar o ambiente de execução do Lightning Engine durante a criação do cluster.	Somente Lightning	default	default	Não	Cluster
spark.dataproc.lightningEngine.runtime	Ativa ou desativa a execução de consulta nativa (NQE) no Lightning Engine.	Somente Lightning	default	default	Sim. Pode ser definido como native ou default.	Job

Limitações

A ativação da execução de consulta nativa nos cenários a seguir pode causar exceções, incompatibilidades do Spark ou fallback da carga de trabalho para o mecanismo padrão do Spark.

Fallbacks

A execução de consulta nativa nos cenários a seguir pode resultar em um fallback da carga de trabalho para o mecanismo de execução do Spark:

• ANSI: se o modo ANSI estiver ativado, a execução fará fallback para o Spark.
• Modo sensível a maiúsculas e minúsculas: a execução de consulta nativa oferece suporte apenas ao modo padrão do Spark que não diferencia maiúsculas de minúsculas. Se o modo sensível a maiúsculas e minúsculas estiver ativado, poderão ocorrer resultados incorretos.
• Verificação de tabela particionada: a execução de consulta nativa oferece suporte à verificação de tabela particionada somente quando o caminho contém as informações de partição. Caso contrário, a carga de trabalho fará fallback para o mecanismo de execução do Spark.

Comportamento incompatível

Comportamentos incompatíveis ou resultados incorretos podem ocorrer quando você usa a execução de consulta nativa nos seguintes casos:

• Funções JSON: a execução de consulta nativa oferece suporte a strings entre aspas duplas, não aspas simples. Resultados incorretos ocorrem com aspas simples. O uso de * no caminho com a função get_json_object retorna NULL.
• Configuração de leitura do Parquet:
  • A execução de consulta nativa trata spark.files.ignoreCorruptFiles como definido para o valor padrão false, mesmo quando definido como true.
  • A execução de consulta nativa ignora spark.sql.parquet.datetimeRebaseModeInRead e retorna apenas o conteúdo do arquivo Parquet. As diferenças entre o calendário híbrido legado e o calendário gregoriano proléptico não são consideradas. Os resultados do Spark podem ser diferentes.
• NaN: indisponível. Resultados inesperados podem ocorrer, por exemplo, quando você usa NaN em uma comparação numérica.
• Leitura colunar do Spark: um erro fatal pode ocorrer porque o vetor colunar do Spark é incompatível com a execução de consulta nativa.
• Spill: quando você define partições de embaralhamento para um número grande, o recurso de spill-to-disk pode acionar um OutOfMemoryException. Se isso ocorrer, reduzir o número de partições poderá eliminar essa exceção.

A seguir

• Acelere as cargas de trabalho e sessões em lote do Spark com o Lightning Engine.