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 de desempenho significativos 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 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 com imagens nativas de IA e ML.

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 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
Propriedade de ativação --engine=default ou desmarque a flag --engine=lightning
Melhor 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 do Lightning Engine:

  • Versão da imagem: o Lightning Engine precisa ser usado com a versão 2.3.3 ou mais recente da imagem do Serviço Gerenciado para Apache Spark.
  • Jobs compatíveis: Spark, PySpark, SparkSQL e SparkR são compatíveis. O mecanismo padrão será executado em outros tipos de job 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 (em vez de operações vinculadas a E/S) que aproveitam as APIs do Spark Dataframe, as APIs do Spark Dataset e as 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) ou da maioria das bibliotecas de machine learning (ML) do Spark.

Requisitos

Os seguintes requisitos se aplicam ao recurso de execução de consultas nativas:

  • 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 imagens Debian-12 são compatíveis. 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. Jobs ativados para NQE que usam processadores ARM vão falhar (mas podem se beneficiar do Lightning Engine sem NQE).

  • Sem GPUs e aceleradores: 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 no Compute Engine.

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 consultas nativas (NQE) 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 Google Cloud conta do. Se você começou a usar o Google Cloud, crie uma conta para avaliar o desempenho dos 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 Google Cloud CLI.

  7. Ao usar um provedor de identidade (IdP) externo, primeiro faça login na gcloud CLI 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 Google Cloud CLI.

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

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

    gcloud init

Funções exigidas

Algumas funções do IAM são necessárias para criar um cluster do Serviço Gerenciado para Apache Spark e enviar jobs ao cluster. Dependendo das políticas da organização, essas funções já podem ter sido concedidas. 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:

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 Serviço Gerenciado para Apache Spark, peça ao administrador para conceder o papel do IAM de Worker do Serviço Gerenciado para Apache Spark (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 Google Cloud console, a Google Cloud CLI, a API Dataproc, o Python ou o Terraform. Também é possível criar um cluster do Serviço Gerenciado para Apache Spark com o Lightning Engine ativado usando as bibliotecas de cliente Go, Java e Node.js.

Console

  1. Noconsole, acesse Criar um cluster do Apache Spark no Compute Engine. Google Cloud Para mais informações, consulte Criar um cluster com o Google Cloud console.

    Acessar Criar um cluster do Apache Spark no Compute Engine

  2. Em Definir o cluster, marque a caixa de seleção Ativar o Lightning Engine para criar um cluster com o Lightning Engine ativado.

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

  4. Defina outras configurações do cluster conforme necessário.

  5. Clique em Criar.

CLI gcloud

  1. Para criar um cluster com o Lightning Engine ativado, execute o gcloud dataproc clusters create comando 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": {
    "gceClusterConfig": {},
    "softwareConfig": {
      "imageVersion": "2.3"
    }
  },
  "engine": "LIGHTNING"
}

  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": {
    "gceClusterConfig": {},
    "softwareConfig": {
      "imageVersion": "2.3",
      "properties": {
        "spark:spark.dataproc.lightningEngine.runtime": "native"
      }
    }
  },
  "engine": "LIGHTNING"
}

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 o 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 consultas nativas, 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

Depois de criar um cluster do Lightning Engine, quando você envia um job do Spark para o cluster, o Lightning Engine é ativado automaticamente no job.

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 a NQE ao criar o cluster do Lightning Engine, é possível ativar a NQE para um job específico 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 spark.dataproc.lightningEngine.runtime=native propriedade:

```none
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 solicitação:

```json
{
  "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ê 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 consultas nativas ao enviar um job do Spark, para um cluster do Lightning Engine, inclua a propriedade spark.dataproc.lightningEngine.runtime=default:

```shell
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:

```json
{
  "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 o job.

Console

  1. Noconsole, acesse a página Detalhes do job. Google Cloud
  2. Verifique se native está listado no campo Execução nativa.

gcloud

  1. Execute o comando gcloud dataproc jobs describe:

    gcloud dataproc clusters 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 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 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 consultas nativas (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 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.

Fallbacks

A execução de consultas nativas 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 consultas nativas 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, resultados incorretos poderão ocorrer.
  • Verificação de tabela particionada: a execução de consultas nativas 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 consultas nativas nos seguintes casos:

  • Funções JSON: a execução de consultas nativas 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 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 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, ao usar 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.
  • 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