Usar o Lightning Engine

O Lightning Engine é um ambiente de execução de alto desempenho para o Apache Spark no Serviço Gerenciado para Apache Spark que acelera cargas de trabalho com uso intensivo de computação e reduz os custos de execução sem exigir mudanças no código do Spark. Ele foi projetado para engenheiros de dados e profissionais de análise que executam cargas de trabalho com uso intensivo de computação que usam APIs Spark DataFrame, APIs Spark Dataset ou consultas Spark SQL.

Vantagens

Os benefícios do Lightning Engine incluem:

• Operações de dados aceleradas: tenha ganhos significativos de desempenho e redução de custos com otimizações na interação com o armazenamento em nuvem, incluindo processamento de metadados, cargas de trabalho de gravação e E/S vetorial.

• Execução inteligente de consultas: 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 de desempenho substanciais, o impacto específico varia de acordo com a carga de trabalho.

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.

Requisitos do Lightning Engine

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 as versões de imagem subminor 2.3 mais recentes, ou as versões de imagem subminor 3.0.2 e mais recentes 3.0 (imagens debian13 e ubuntu24).
• Jobs compatíveis: Spark, PySpark, SparkSQL e SparkR. O mecanismo padrão é executado em outros tipos de serviço enviados para 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 o hardware do Google, que aumenta o desempenho executando partes de uma consulta do Spark fora da JVM.

A NQE é recomendada para:

Tarefas com uso intensivo de computação que usam APIs Spark DataFrame e APIs Spark Dataset, além de consultas Spark SQL que leem dados de arquivos e tabelas Parquet, ORC, Apache Iceberg e Delta Lake. O formato do arquivo de saída não afeta o desempenho.

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.

Execução de consulta nativa em ARM

O Serviço Gerenciado para Apache Spark oferece suporte à execução de consultas nativas no Lightning Engine na arquitetura ARM, otimizada especificamente para processadores Google Axion em VMs ARM C4A (consulte Tipos de máquina ARM compatíveis com o Serviço Gerenciado para Apache Spark) usando a imagem 2.3-ubuntu22-arm. As instâncias C4A do Google Axion são VMs baseadas em ARM criadas em núcleos ARM Neoverse V2 que oferecem melhorias significativas de custo-benefício.

A execução do NQE em instâncias ARM do Google Axion combina custo-benefício no nível do hardware e alta largura de banda de memória por núcleo com aceleração de consulta vetorial nativa no nível do software, reduzindo significativamente os tempos de execução de consultas e o custo total de propriedade (TCO).

Os principais benefícios do ARM incluem:

• Aceleração de 2,5x a 4x em relação ao Spark de código aberto: oferece melhorias de desempenho de 2,5x a 4x em comparação com o Apache Spark de código aberto em cargas de trabalho analíticas.
• Otimização de custos: maximiza a vantagem de custo-benefício das instâncias do Google Axion C4A, que oferecem um custo-benefício até 65% melhor em comparação com instâncias x86 semelhantes.
• Paridade total de operadores e formatos: paridade total com os operadores NQE x86, com aceleração nativa para os formatos de tabela do Cloud Storage Parquet, Apache Iceberg e Delta Lake.
• Zero mudanças de código: ativação simples em clusters ARM usando flags de configuração padrão sem modificar o código do aplicativo Spark.

Requisitos da execução de consulta nativa

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

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

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

• Sem GPUs e aceleradores: os jobs com NQE ativada enviados em aceleradores de GPU vão falhar, mas podem se beneficiar do Lightning Engine sem NQE.

• Tipos de dados: não há suporte para entradas dos seguintes tipos de dados:

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

Requisitos de arquitetura e sistema operacional

Os requisitos de NQE variam de acordo com a arquitetura do processador:

Preços

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

Criar um cluster do Lightning Engine

Nesta seção, mostramos 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, na sigla em inglês) no cluster ao criá-lo ou ativar a NQE posteriormente para jobs específicos do Spark enviados ao cluster.

Antes de começar

1. In the Cloud de Confiance console, on the project selector page, select or create a Cloud de Confiance 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.

   Go to project selector

2. Verify that you have the permissions required to complete this guide.

3. Verify that billing is enabled for your Cloud de Confiance project.

4. Enable the Dataproc API, if it is not already enabled.

   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

5. Install the Google Cloud CLI.

6. Configure the gcloud CLI to use your federated identity.

   For more information, see Sign in to the gcloud CLI with your federated identity.

7. To initialize the gcloud CLI, run the following command:

   gcloud init

Funções exigidas

Alguns papéis do Identity and Access Management (IAM) são necessários para criar um cluster do Serviço Gerenciado para Apache Spark e enviar jobs para ele. Dependendo das políticas da organização, um proprietário de projeto do Cloud ou administrador de serviço pode já 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:

• 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.

Crie o cluster

Os exemplos a seguir mostram como criar um cluster do Lightning Engine usando o console do Cloud de Confiance , 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.

Verificar o mecanismo do cluster

Enviar um job com o Lightning Engine

Se você ativou o Lightning Engine ao criar um cluster, quando enviar um job do Spark para o cluster, o Lightning Engine será 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, na sigla em inglês) 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 ativá-la para um job ao enviá-lo, conforme mostrado nos exemplos a seguir.

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

{
  "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, na sigla em inglês) ao criar um cluster do Lightning Engine, todos os jobs do Spark serão executados com a NQE ativada, a menos que você a desative 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 dataproc jobs submit spark \
    --cluster=CLUSTER_NAME \
    --region=REGION \
    --properties=spark.dataproc.lightningEngine.runtime=default \
    -- ...

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

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

Depois de enviar um job para um cluster do Lightning Engine, verifique se a execução de consulta nativa está ativada para o job.

Parâmetros de configuração

A tabela a seguir resume os principais parâmetros de configuração do Lightning Engine e da execução de consultas nativas.

Limitações

Ativar a execução de consultas nativas 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.

Substitutos

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

• ANSI: se o modo ANSI estiver ativado, a execução será revertida para o Spark.
• Modo que diferencia maiúsculas de minúsculas: a execução de consultas nativas só é compatível com o modo padrão do Spark, que não diferencia maiúsculas de minúsculas. Se o modo que diferencia maiúsculas de minúsculas estiver ativado, poderão ocorrer resultados incorretos.
• Verificação de tabela particionada: a execução de consulta nativa é compatível com a verificação de tabela particionada apenas quando o caminho contém as informações da partição. Caso contrário, a carga de trabalho volta para o mecanismo de execução do Spark.

Comportamento incompatível

Comportamentos incompatíveis ou resultados incorretos podem ocorrer ao usar a execução de consulta nativa nos seguintes casos:

• Funções JSON: a execução de consultas nativas é compatível com strings entre aspas duplas, não aspas simples. Resultados incorretos ocorrem com aspas simples. Usar * 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 como 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: não compatível. Resultados inesperados podem ocorrer, por exemplo, quando você usa NaN em uma comparação numérica.
• Leitura colunar do Spark: pode ocorrer um erro fatal porque o vetor colunar do Spark é incompatível com a execução de consulta nativa.
• Spill: quando você define as partições de embaralhamento como um número grande, o recurso de spill para disco pode acionar um OutOfMemoryException. Se isso ocorrer, reduzir o número de partições pode eliminar essa exceção.

A seguir

• Acelere as cargas de trabalho e as sessões em lote do Spark com o Lightning Engine.
• Confira os tipos de máquina ARM compatíveis com o Serviço Gerenciado para Apache Spark.
• Saiba como ajustar jobs do Spark para otimizar o desempenho.