Esta página foi traduzida pela API Cloud Translation.

Acelere as cargas de trabalho em lote e as sessões interativas com a execução de consultas nativas

Este documento descreve quando e como ativar a execução de consultas nativas para acelerar as cargas de trabalho em lote e as sessões interativas do Serverless para Apache Spark.

Requisitos de execução de consultas nativas

A execução de consultas nativas sem servidor para Apache Spark só está disponível com cargas de trabalho em lote e sessões interativas que usam o 1.2.26+, o 2.2.26+ ou uma versão do runtime do Spark posterior, executados no nível de preços premium do sem servidor para Apache Spark. O preço do nível Premium é cobrado a um custo mais elevado do que o preço do nível padrão, mas não existe um custo adicional para a execução de consultas nativas. Para ver informações de preços, consulte o artigo Preços do Serverless para Apache Spark.

Propriedades de execução de consultas nativas

Esta secção apresenta as propriedades de atribuição de recursos do Spark obrigatórias e opcionais que pode usar para ativar e personalizar a execução de consultas nativas para a sua carga de trabalho em lote ou sessão interativa.

Definições de propriedade obrigatórias

spark.dataproc.runtimeEngine=native: o motor de tempo de execução da carga de trabalho tem de ser definido como native para substituir o motor de tempo de execução spark predefinido.
spark.dataproc.spark.driver.compute.tier=premium e spark.dataproc.executor.compute.tier=premium: estas propriedades de nível de preços têm de ser definidas para o nível de preços premium.

Propriedades de atribuição de recursos opcionais

spark.dataproc.driver.disk.tier, spark.dataproc.driver.disk.size, spark.dataproc.executor.disk.tier e spark.dataproc.executor.disk.size: use estas propriedades para definir e configurar o nível e o tamanho do disco premium para os processos do controlador e do executor do Spark.

Os níveis de disco premium usam o serviço Shuffle baseado em colunas em vez de linhas para oferecer um melhor desempenho. Para um melhor débito de E/S de mistura, use os níveis de disco premium do controlador e do executor com um tamanho de disco suficientemente grande para acomodar ficheiros de mistura.

spark.driver.memory, spark.driver.memoryOverhead, spark.executor.memory, spark.executor.memoryOverhead e spark.memory.offHeap.size: use estas propriedades para ajustar a memória fornecida aos processos do controlador e do executor do Spark.

Pode configurar a memória de uma das seguintes formas:

Opção 1: configure apenas a memória fora da pilha (spark.memory.offHeap.size) com um valor especificado. A execução de consultas nativas usa o valor especificado como memória fora do heap e atribui 1/7th adicionais do valor de memória fora do heap como memória no heap (spark.executor.memory).
Opção 2: configure a memória no heap (spark.executor.memory) e a memória fora do heap (spark.memory.offHeap.size). A quantidade que atribui à memória fora do heap tem de ser superior à quantidade que atribui à memória no heap.

Se não configurar a memória fora do heap (spark.memory.offHeap.size) e a memória no heap (spark.executor.memory), o motor de execução de consultas nativas divide uma quantidade predefinida de memória 4g numa proporção de 6:1 entre a memória fora do heap e a memória no heap.

Recomendação: atribua memória fora do heap à memória no heap numa proporção de 6:1.

Exemplos:

Definições da memória sem execução de consultas nativas	Definições de memória recomendadas com a execução de consultas nativas
`spark.executor.memory`	`spark.memory.offHeap.size`	`spark.executor.memory`
7g	6G	1g
14g	12g	2g
28g	24g	4G
56g	48g	8g

Execute a ferramenta de qualificação

Para identificar cargas de trabalho em lote que podem alcançar tempos de execução mais rápidos com a execução de consultas nativas (NQE), pode usar a ferramenta de qualificação. A ferramenta analisa os registos de eventos do Spark para estimar as potenciais poupanças de tempo de execução e identificar quaisquer operações que não sejam suportadas pelo motor NQE.

Google Cloud oferece dois métodos para executar a análise de qualificação: tarefa de qualificação e script de qualificação. A abordagem recomendada para a maioria dos utilizadores é a tarefa de qualificação, que automatiza a deteção e a análise de cargas de trabalho em lote. O script de qualificação alternativo está disponível para o exemplo de utilização específico de analisar um ficheiro de registo de eventos conhecido. Escolha o método mais adequado ao seu exemplo de utilização:

Tarefa de qualificação (recomendada): este é o método principal e recomendado. É uma tarefa do PySpark que descobre e analisa automaticamente cargas de trabalho em lote recentes em um ou mais Google Cloud projetos e regiões. Use este método quando quiser fazer uma análise abrangente sem ter de localizar manualmente ficheiros de registo de eventos individuais. Esta abordagem é ideal para a avaliação em grande escala da adequação da NQE.
Script de qualificação (alternativo): este é um método alternativo para exemplos de utilização avançados ou específicos. É um script de shell que analisa um ficheiro de registo de eventos do Spark único ou todos os registos de eventos num diretório específico do Cloud Storage. Use este método se tiver o caminho do Cloud Storage para os registos de eventos que quer analisar.

Tarefa de qualificação

A tarefa de qualificação simplifica a análise em grande escala através da procura programática de cargas de trabalho em lote do Serverless para Apache Spark e do envio de uma tarefa de análise distribuída. A ferramenta avalia os trabalhos em toda a sua organização, eliminando a necessidade de encontrar e especificar manualmente os caminhos dos registos de eventos.

Conceda funções de IAM

Para que a tarefa de qualificação aceda aos metadados da carga de trabalho em lote e leia os registos de eventos do Spark no Cloud Logging, a conta de serviço que executa a carga de trabalho tem de ter as seguintes funções do IAM concedidas em todos os projetos a serem analisados:

Envie a tarefa de qualificação

Envia a tarefa de qualificação através da ferramenta CLI gcloud. A tarefa inclui um script PySpark e um ficheiro JAR alojados num contentor do Cloud Storage público.

Pode executar a tarefa num dos seguintes ambientes de execução:

Como carga de trabalho em lote sem servidor para o Apache Spark. Esta é uma execução de tarefas simples e autónoma.
Como uma tarefa executada num cluster do Dataproc no Compute Engine. Esta abordagem pode ser útil para integrar a tarefa num fluxo de trabalho.

Argumentos de trabalho

Argumento	Descrição	Obrigatório?	Valor predefinido
`--project-ids`	Um único ID do projeto ou uma lista separada por vírgulas de IDs de projetos do Google Cloud para procurar cargas de trabalho em lote.	Não	O projeto no qual a tarefa de qualificação está a ser executada.
`--regions`	Uma única região ou uma lista de regiões separadas por vírgulas para analisar nos projetos especificados.	Não	Todas as regiões nos projetos especificados.
`--start-time`	A data de início para filtrar lotes. Apenas são analisados os lotes criados nesta data ou após a mesma (formato: AAAA-MM-DD).	Não	Não é aplicado nenhum filtro de data de início.
`--end-time`	A data de fim para filtrar lotes. Apenas são analisados os lotes criados nesta data ou antes (formato: AAAA-MM-DD).	Não	Não é aplicado nenhum filtro de data de conclusão.
`--limit`	O número máximo de lotes a analisar por região. Os lotes mais recentes são analisados primeiro.	Não	São analisados todos os lotes que correspondem aos outros critérios de filtro.
`--output-gcs-path`	O caminho do Cloud Storage (por exemplo, `gs://your-bucket/output/`) onde os ficheiros de resultados vão ser escritos.	Sim	Nenhum.
`--input-file`	O caminho do Cloud Storage para um ficheiro de texto para análise em massa. Se for fornecido, este argumento substitui todos os outros argumentos de definição do âmbito (`--project-ids`, `--regions`, `--start-time`, `--end-time` e `--limit`).	Não	Nenhum.

Exemplos de tarefas de qualificação

Uma tarefa em lote sem servidor para o Apache Spark para realizar análises simples e ad hoc. Os argumentos da tarefa são apresentados após o separador --.

gcloud dataproc batches submit pyspark gs://qualification-tool/performance-boost-qualification.py \
    --project=PROJECT_ID \
    --region=REGION \
    --jars=gs://qualification-tool/dataproc-perfboost-qualification-1.2.jar \
    -- \
    --project-ids=COMMA_SEPARATED_PROJECT_IDS \
    --regions=COMMA_SEPARATED_REGIONS \
    --limit=MAX_BATCHES \
    --output-gcs-path=gs://BUCKET

Uma tarefa em lote sem servidor para o Apache Spark para analisar até 50 dos lotes mais recentes encontrados em sample_project na região us-central1. Os resultados são escritos no contentor no Cloud Storage. Os argumentos da tarefa são apresentados após o separador --.

gcloud dataproc batches submit pyspark gs://qualification-tool/performance-boost-qualification.py \
    --project=PROJECT_ID \
    --region=US-CENTRAL1 \
    --jars=gs://qualification-tool/dataproc-perfboost-qualification-1.2.jar \
    -- \
    --project-ids=PROJECT_ID \
    --regions=US-CENTRAL1 \
    --limit=50 \
    --output-gcs-path=gs://BUCKET/

Uma tarefa do Dataproc no Compute Engine enviada para um cluster do Dataproc para análise em massa num fluxo de trabalho de análise repetível, automatizado ou em grande escala. Os argumentos da tarefa são colocados num INPUT_FILE que é carregado para um BUCKET no Cloud Storage. Este método é ideal para analisar diferentes intervalos de datas ou limites de lotes em diferentes projetos e regiões numa única execução.
```
gcloud dataproc jobs submit pyspark gs://qualification-tool/performance-boost-qualification.py \
    --cluster=CLUSTER_NAME \
    --region=REGION \
    --jars=gs://qualification-tool/dataproc-perfboost-qualification-1.2.jar \
    -- \
    --input-file=gs://INPUT_FILE \
    --output-gcs-path=gs://BUCKET
```
Notas:

INPUT_FILE: cada linha no ficheiro representa um pedido de análise distinto e usa um formato de flags de uma única letra seguidas dos respetivos valores, como -p PROJECT-ID -r REGION -s START_DATE -e END_DATE -l LIMITS.

Exemplo de conteúdo do ficheiro de entrada:
```
-p project1 -r us-central1 -s 2024-12-01 -e 2024-12-15 -l 100
-p project2 -r europe-west1 -s 2024-11-15 -l 50
```
Estes argumentos direcionam a ferramenta para analisar os dois âmbitos seguintes:
- Até 100 lotes no project1 na região us-central1 criados entre 1 de dezembro de 2025 e 15 de dezembro de 2025.
- Até 50 lotes no projeto2 na região europe-west1 criados a 15 de novembro de 2025 ou posteriormente.

Guião de qualificação

Use este método se tiver o caminho direto do Cloud Storage para um registo de eventos do Spark específico que quer analisar. Esta abordagem requer que transfira e execute um script de shell, run_qualification_tool.sh, numa máquina local ou numa VM do Compute Engine configurada com acesso ao ficheiro de registo de eventos no Cloud Storage.

Siga os passos abaixo para executar o script em ficheiros de eventos de carga de trabalho em lote do Serverless for Apache Spark.

1.Copie o run_qualification_tool.sh para um diretório local que contenha os ficheiros de eventos do Spark a analisar.

Execute o script de qualificação para analisar um ficheiro de eventos ou um conjunto de ficheiros de eventos contidos no diretório do script.
```
./run_qualification_tool.sh -f EVENT_FILE_PATH/EVENT_FILE_NAME \
    -o CUSTOM_OUTPUT_DIRECTORY_PATH \
    -k SERVICE_ACCOUNT_KEY  \
    -x MEMORY_ALLOCATEDg  \
    -t PARALLEL_THREADS_TO_RUN
```
Flags e valores:

-f (obrigatório): consulte as localizações dos ficheiros de eventos Spark para localizar os ficheiros de eventos da carga de trabalho Spark.
- EVENT_FILE_PATH (obrigatório, a menos que EVENT_FILE_NAME seja especificado): caminho do ficheiro de eventos a analisar. Se não for indicado, considera-se que o caminho do ficheiro de eventos é o diretório atual.
- EVENT_FILE_NAME (obrigatório, a menos que EVENT_FILE_PATH seja especificado): Nome do ficheiro de eventos a analisar. Se não for indicado, os ficheiros de eventos encontrados recursivamente no diretório EVENT_FILE_PATH são analisados.
-o(opcional): se não for fornecido, a ferramenta cria ou usa um diretório output existente no diretório atual para colocar os ficheiros de saída.
- CUSTOM_OUTPUT_DIRECTORY_PATH: caminho do diretório de saída para os ficheiros de saída.
-k (opcional):
- SERVICE_ACCOUNT_KEY: A chave da conta de serviço no formato JSON, se for necessária para aceder à EVENT_FILE_PATH.
-x (opcional):
- MEMORY_ALLOCATED: memória em gigabytes a atribuir à ferramenta. Por predefinição, a ferramenta usa 80% da memória livre disponível no sistema e todos os núcleos da máquina disponíveis.
-t(opcional):
- PARALLEL_THREADS_TO_RUN: o número de threads paralelos para a execução da ferramenta. Por predefinição, a ferramenta executa todos os núcleos.
Exemplo de utilização de comandos:
```
./run_qualification_tool.sh -f gs://dataproc-temp-us-east1-9779/spark-job-history \
    -o perfboost-output -k /keys/event-file-key -x 34g -t 5
```
Neste exemplo, a ferramenta de validação percorre o diretório gs://dataproc-temp-us-east1-9779/spark-job-history e analisa os ficheiros de eventos do Spark contidos neste diretório e nas respetivas subdiretórios. O acesso ao diretório é fornecido pela /keys/event-file-key. A ferramenta usa 34 GB memory para execução e executa 5 threads paralelos.

Localizações de ficheiros de eventos Spark

Execute qualquer um dos seguintes passos para encontrar os ficheiros de eventos do Spark para cargas de trabalho em lote sem servidor para o Apache Spark:

No Cloud Storage, encontre o spark.eventLog.dir para a carga de trabalho e, em seguida, transfira-o.
1. Se não conseguir encontrar o spark.eventLog.dir, defina o spark.eventLog.dir para uma localização do Cloud Storage e, em seguida, volte a executar a carga de trabalho e transfira o spark.eventLog.dir.
Se tiver configurado o Spark History Server para a tarefa em lote:
1. Aceda ao Spark History Server e, de seguida, selecione a carga de trabalho.
2. Clique em Transferir na coluna Registo de eventos.

Ficheiros de saída da ferramenta de qualificação

Quando a tarefa de qualificação ou a análise de scripts estiver concluída, a ferramenta de qualificação coloca os seguintes ficheiros de saída num diretório perfboost-output no diretório atual:

AppsRecommendedForBoost.tsv: Uma lista separada por tabulações de aplicações recomendadas para utilização com a execução de consultas nativas.
UnsupportedOperators.tsv: Uma lista separada por tabulações de aplicações não recomendadas para utilização com a execução de consultas nativas.

`AppsRecommendedForBoost.tsv` ficheiro de saída

A tabela seguinte mostra o conteúdo de um exemplo de AppsRecommendedForBoost.tsvficheiro de saída. Contém uma linha para cada aplicação analisada.

Exemplo de AppsRecommendedForBoost.tsv ficheiro de saída:

applicationId	applicationName	rddPercentage	unsupportedSqlPercentage	totalTaskTime	supportedTaskTime	supportedSqlPercentage	recommendedForBoost	expectedRuntimeReduction
app-2024081/batches/083f6196248043938-000	projects/example.com:dev/locations/us-central1 6b4d6cae140f883c0 11c8e	0,00%	0,00%	548924253	548924253	100,00%	TRUE	30,00%
app-2024081/batches/60381cab738021457-000	projects/example.com:dev/locations/us-central1 474113a1462b426bf b3aeb	0,00%	0,00%	514401703	514401703	100,00%	TRUE	30,00%

Descrições das colunas:

applicationId: o ApplicationID da aplicação Spark. Use este campo para identificar a carga de trabalho em lote correspondente.
applicationName: o nome da aplicação Spark.
rddPercentage: a percentagem de operações RDD na aplicação. As operações RDD não são suportadas pela execução de consultas nativas.
unsupportedSqlPercentage: Percentagem de operações SQL não suportadas pela execução de consultas nativas.
totalTaskTime: tempo de tarefa cumulativo de todas as tarefas executadas durante a execução da aplicação.
supportedTaskTime: o tempo total da tarefa suportado pela execução de consultas nativas.

As seguintes colunas fornecem informações importantes para ajudar a determinar se a execução de consultas nativas pode beneficiar a sua carga de trabalho em lote:

supportedSqlPercentage: a percentagem de operações SQL suportadas pela execução de consultas nativas. Quanto maior for a percentagem, maior é a redução do tempo de execução que pode ser alcançada executando a aplicação com a execução de consultas nativas.
recommendedForBoost: se TRUE, é recomendado executar a aplicação com a execução de consultas nativas. Se recommendedForBoost for FALSE, não use a execução de consultas nativas na carga de trabalho em lote.
expectedRuntimeReduction: a percentagem de redução esperada no tempo de execução da aplicação quando executa a aplicação com a execução de consultas nativas.

`UnsupportedOperators.tsv` ficheiro de saída.

O ficheiro de saída UnsupportedOperators.tsv contém uma lista de operadores usados em aplicações de carga de trabalho que não são suportados pela execução de consultas nativas. Cada linha no ficheiro de saída apresenta um operador não suportado.

Descrições das colunas:

unsupportedOperator: o nome do operador que não é suportado pela execução de consultas nativas.
cumulativeCpuMs: o número de milissegundos da CPU consumidos durante a execução do operador. Este valor reflete a importância relativa do operador na aplicação.
count: o número de vezes que o operador é usado na aplicação.

Use a execução de consultas nativas

Pode usar a execução de consultas nativas com a sua aplicação definindo as propriedades de execução de consultas nativas quando criar a carga de trabalho em lote, sessão interativa ou modelo de sessão que executa a sua aplicação.

Use a execução de consultas nativas com cargas de trabalho em lote

Pode usar a Google Cloud consola, a Google Cloud CLI ou a API Dataproc para ativar a execução de consultas nativas numa carga de trabalho em lote.

Consola

Use a Google Cloud consola para ativar a execução de consultas nativas numa carga de trabalho em lote.

Na Google Cloud consola:
1. Aceda a Lotes do Dataproc.
2. Clique em Criar para abrir a página Criar lote.
Selecione e preencha os seguintes campos para configurar o lote para a execução de consultas nativas:
- Contentor:
  - Versão do tempo de execução: selecione 1.2, 2.2 ou um número de versão major.minor superior. Consulte as versões do tempo de execução sem servidor para o Apache Spark suportadas.
- Configuração do nível do executor e do controlador:
  - Selecione Premium para todos os níveis (Driver Compute Tier e Execute Compute Tier).
- Propriedades: introduza pares Key (nome da propriedade) e Value para especificar as propriedades de execução de consultas nativas:
  
  Chave Valor
  
  spark.dataproc.runtimeEngine nativo/nativa
Preencha, selecione ou confirme outras definições de cargas de trabalho em lote. Consulte Envie uma carga de trabalho em lote do Spark.
Clique em Enviar para executar a carga de trabalho em lote do Spark.

Chave	Valor
`spark.dataproc.runtimeEngine`	nativo/nativa

gcloud

Defina as seguintes flags de comando da CLI gcloud gcloud dataproc batches submit spark para configurar uma carga de trabalho em lote para a execução de consultas nativas:

gcloud dataproc batches submit spark \
    --project=PROJECT_ID \
    --region=REGION \
    --jars=file:///usr/lib/spark/examples/jars/spark-examples.jar \
    --class=org.apache.spark.examples.SparkPi \
    --properties=spark.dataproc.runtimeEngine=native,spark.dataproc.driver.compute.tier=premium,spark.dataproc.executor.compute.tier=premium \
    OTHER_FLAGS_AS_NEEDED

Notas:

PROJECT_ID: o ID do seu Google Cloud projeto. Os IDs dos projetos estão listados na secção Informações do projeto no Google Cloud painel de controlo da consola.
REGION: Uma região do Compute Engine disponível para executar a carga de trabalho.
OTHER_FLAGS_AS_NEEDED: consulte o artigo Envie uma carga de trabalho em lote do Spark.

API

Defina os seguintes campos da API Dataproc para configurar uma carga de trabalho em lote para a execução de consultas nativas:

RuntimeConfig.properties: Defina as seguintes propriedades de execução de consultas nativas:
```
"spark.dataproc.runtimeEngine":"native"
"spark.dataproc.driver.compute.tier":"premium"
"spark.dataproc.executor.compute".tier:"premium"
```
Notas:
- Consulte o artigo Envie uma carga de trabalho em lote do Spark para definir outros campos da API de carga de trabalho em lote.

Quando usar a execução de consultas nativas

Use a execução de consultas nativas nos seguintes cenários:

APIs Spark Dataframe, APIs Spark Dataset e consultas Spark SQL que leem dados de ficheiros Parquet e ORC. O formato do ficheiro de saída não afeta o desempenho da execução de consultas nativas.
Cargas de trabalho recomendadas pela ferramenta de qualificação de execução de consultas nativas.

Quando não usar a execução de consultas nativas

Entradas dos seguintes tipos de dados:

Byte: ORC e Parquet
Indicação de tempo: ORC
Struct, Array, Map: Parquet

Limitações

A ativação da execução de consultas nativas nos seguintes cenários pode causar exceções, incompatibilidades com o Spark ou o recurso de carga de trabalho para o motor do Spark predefinido.

Alternativos

A execução de consultas nativas na execução seguinte pode resultar no recurso da carga de trabalho para o motor de execução do Spark, o que resulta em regressão ou falha.

ANSI: se o modo ANSI estiver ativado, a execução recorre ao Spark.
Modo sensível a maiúsculas e minúsculas: a execução de consultas nativas suporta apenas o modo predefinido do Spark que não é sensível a maiúsculas e minúsculas. Se o modo sensível a maiúsculas e minúsculas estiver ativado, podem ocorrer resultados incorretos.
Análise de tabelas particionadas: a execução de consultas nativas suporta a análise de tabelas particionadas apenas quando o caminho contém as informações de partição. Caso contrário, a carga de trabalho recorre ao motor de execução do Spark.

Comportamento incompatível

Pode ocorrer um comportamento incompatível ou resultados incorretos quando usa a execução de consultas nativas nos seguintes casos:

Funções JSON: a execução de consultas nativas suporta strings entre aspas duplas e não aspas simples. Os resultados incorretos ocorrem com as aspas simples. A utilização de "*" no caminho com a função get_json_object devolve NULL.
Configuração de leitura de Parquet:
- A execução de consultas nativas trata spark.files.ignoreCorruptFiles como definido para o valor false predefinido, mesmo quando definido para true.
- A execução de consultas nativas ignora spark.sql.parquet.datetimeRebaseModeInRead e devolve apenas o conteúdo do ficheiro Parquet. As diferenças entre o calendário híbrido antigo (juliano-gregoriano) e o calendário gregoriano proléptico não são consideradas. Os resultados do Spark podem ser diferentes.
NaN: não suportado. Podem ocorrer resultados inesperados, por exemplo, quando usa NaN numa comparação numérica.
Leitura de colunas do Spark: pode ocorrer um erro fatal, uma vez que o vetor de colunas do Spark é incompatível com a execução de consultas nativas.
Transbordo: quando as partições de aleatorização estão definidas para um número elevado, a funcionalidade de transbordo para o disco pode acionar um OutOfMemoryException. Se isto acontecer, reduzir o número de partições pode eliminar esta exceção.