Usar o Lightning Engine

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

Vantagens

Os benefícios do Lightning Engine incluem:

  • Operações de dados aceleradas: tenha ganhos significativos de performance e economia 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 vetorizada.

  • Execução inteligente de consultas: aproveite 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. Ele é mais adequado para tarefas com uso intenso de computação que aproveitam as APIs DataFrame e Dataset do Spark e 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 flag --engine=lightning
Ideal para Trabalhos de uso geral, desenvolvimento e teste Cargas de trabalho em escala empresarial que exigem aceleração significativa
Principais benefícios Desempenho referencial Interação otimizada com o armazenamento em nuvem, execução inteligente de consultas

Requisitos

Os seguintes requisitos se aplicam ao recurso Lightning Engine:

  • Versão da imagem: o Lightning Engine precisa ser usado com a versão 2.3.3 ou mais recente da versão de imagem do Serviço Gerenciado para Apache Spark.
  • Jobs compatíveis: Spark, PySpark, SparkSQL e SparkR. O mecanismo padrão é executado em outros tipos de jobs enviados a um cluster do Lightning Engine.

Execução de consultas nativas

A execução de consultas nativas (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 DataFrame e Dataset do Spark, além de consultas SQL do Spark que leem dados de arquivos Parquet e ORC. O formato do arquivo de saída não afeta o desempenho dele.
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 aprendizado de máquina (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 consultas nativas:

  • Mecanismo de execução: o NQE está disponível apenas em clusters ativados com o mecanismo Lightning 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. O mecanismo padrão será executado (sem NQE) em outros tipos de jobs 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: entradas dos seguintes tipos de dados não são aceitas:

    • 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

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 consultas nativas (NQE, na sigla em inglês) no cluster ao criar o cluster ou ativar a NQE mais tarde para jobs específicos do Spark enviados ao cluster.

Antes de começar

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

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

    Go to project selector

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

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

  5. Enable the Dataproc API.

    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 API

  6. Instale a CLI do Google Cloud.

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

  8. Para inicializar a CLI gcloud, execute o seguinte comando: 

    gcloud init

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

    Go to project selector

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

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

  12. Enable the Dataproc API.

    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 API

  13. Instale a CLI do Google Cloud.

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

  15. 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 a ele. Dependendo das políticas da organização, um proprietário do projeto na nuvem ou um administrador de serviços pode já ter concedido esses papéis a você ou a uma conta de serviço. Para verificar as concessões de função, consulte Você precisa conceder funções?.

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 Managed Service for Apache Spark, peça ao administrador para conceder a você os seguintes papéis do IAM:

Função 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 Managed Service para Apache Spark, peça ao administrador para conceder o papel do IAM 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 Google Cloud , 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 em Go, Java e Node.js.

Console

  1. Abra a página Criar cluster.
  2. Clique em Configuração adicional para abrir a seção.
  3. Edite Personalização e outros.
  4. No painel 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. Configure outras definições do cluster conforme necessário.
  8. Clique em Criar cluster.

CLI da gcloud

  1. Para criar um cluster com o Lightning Engine ativado, execute o comando gcloud dataproc clusters create com a flag --engine=lightning. 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 campo engine 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 recurso google_dataproc_cluster.

Verificar o mecanismo do cluster

Console

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

gcloud

  1. Para verificar o mecanismo e o NQE (se ativado), 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, ele será ativado por padrão no job do Spark enviado ao cluster.

Ativar a execução de consultas nativas para um job

Se você ativou a execução de consultas nativas (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 o NQE ao criar o cluster do Lightning Engine, é possível ativar o NQE para um job ao enviá-lo, conforme mostrado nos exemplos a seguir.

gcloud

Para ativar a execução de consultas nativas 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 consultas nativas 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 consultas nativas para um job

Se você ativou a execução de consultas nativas (NQE) 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 o NQE para um job específico do Spark ao enviar o job, conforme mostrado nos exemplos a seguir.

gcloud

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

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

API

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

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

Verificar a execução de consultas nativas para um job

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

Console

  1. No console Google Cloud , 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 do 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 do Lightning Engine e da execução de consultas nativas.

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 tempo de execução do mecanismo Lightning durante a criação do cluster. Apenas Lightning default default Não Cluster
spark.dataproc.lightningEngine.runtime Ativa ou desativa a execução de consultas nativas (NQE, na sigla em inglês) no Lightning Engine. Apenas Lightning default default Sim. Pode ser definido como native ou default. Job

Limitações

Ativar a execução de consultas nativas nos seguintes cenários 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 seguintes cenários 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 vai voltar para o Spark.
  • Modo sensível a maiúsculas e 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 sensível a maiúsculas e minúsculas estiver ativado, poderão ocorrer resultados incorretos.
  • Verificação de tabela particionada: a execução de consultas nativas só é compatível com a verificação de tabela particionada quando o caminho contém as informações de partição. Caso contrário, a carga de trabalho vai usar o mecanismo de execução do Spark.

Comportamento incompatível

Um comportamento incompatível ou resultados incorretos podem ocorrer quando você usa a execução de consultas nativas nos seguintes casos:

  • Funções JSON: a execução de consultas nativas é compatível com strings entre aspas duplas, não 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 consultas nativas trata spark.files.ignoreCorruptFiles como definido para o valor padrão false, mesmo quando definido como true.
    • A execução de consultas nativas 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 proleptico não são consideradas. Os resultados do Spark podem variar.
  • 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 consultas nativas.
  • Transbordamento: quando você define um grande número de partições de embaralhamento, o recurso de transbordamento para disco pode acionar um OutOfMemoryException. Se isso acontecer, reduza o número de partições para eliminar essa exceção.

A seguir