Spark & Scala Cache Lições do Projeto ETL
O que está em cache em Spark? O armazenamento em cache em Spark significa armazenar dados calculados na memória, para que você não precise recalculá -los toda vez que o usar. Pense nisso como salvar seu trabalho – depois de fazer o cálculo difícil, você mantém o resultado à mão para uso posterior. Padrões de uso de cache encontrados neste projeto 1. Cache estratégico de dados transformados O que encontramos: Val Sellosds: DataSet[SelloSource] = SellosSourCetransformer .ProcesaultImossellosActivosporeFechaPorpatente (SellSDF) .cache () val contratospmfds: conjunto de dados[ContratosPMFSource] = ContratospmfsourCetransformer .ProcessActiveContractSpmf (Contratospmfdf) .cache () Digite o modo de tela fullcreen Sair da tela cheia Lição: conjuntos de dados de cache diretamente após transformações complexas que serão usadas várias vezes. Isso impede a Spark de recalcular as mesmas operações caras. 2 Dados de referência em cache o que encontramos: val empresasds = empresatransformer.TransformemPRESAS (Sellosds) .cache () val gerenciass = gerencitransformer.transformGerencias (Sellosds) .cache () vals participantes = participantes geradores. Lição do modo de tela completa: dados de referência de cache (como informações da empresa, departamentos, participantes) porque esses pequenos conjuntos de dados são unidos a conjuntos de dados maiores várias vezes durante o processo ETL. 3 cache após operações da janela o que encontramos no transformador: RAWDATA .Filter (F.Lower (F.Col (“estado”)) === “Activo”) .Transform (df => {val windowspec = window.partitionby (f.col (“patente”). df.withcolumn (“row_num”, f.row_number (). over (windowspec)) .filter (f.col (“row_num”) === 1) .drop (“row_num”)}) inserir o modo de tela cheia Exit de tela cheia lição de lição de tela: lição de janela é cara. Quando você faz funções complexas de janela (como obter o registro mais recente por grupo), cache o resultado se você o usar novamente. Problemas -chave que encontramos 1. Problema de limpeza de cache ausente: os conjuntos de dados do projeto Caches, mas nunca chama o não persistente () para a memória livre. Impacto: a memória mantém o crescimento durante a execução do ETL, que pode causar: erros de desempenho mais lentos resíduos de recursos de desempenho melhor abordagem: tente {val cachedds = algos resformatória (). Cache () // use o modo de conjunto de dados em cache. Problema: Alguns conjuntos de dados em cache são usados apenas uma ou duas vezes. Regra geral: cache apenas se você usar os dados mais de 3 vezes, ou se o cálculo for muito caro. 3. Nenhum problema de gerenciamento de nível de armazenamento de cache: usando configurações de cache padrão sem considerar a memória versus trade-offs do disco. Better approach: // For frequently accessed small data dataset.persist(StorageLevel.MEMORY_ONLY) // For large data that might not fit in memory dataset.persist(StorageLevel.MEMORY_AND_DISK) Enter fullscreen mode Exit fullscreen mode Best Practices from This Project ✅ Good Practices Found Cache after complex transformations – The project correctly caches after expensive operations like window functions and joins. Dados de referência de cache – pequenas tabelas de pesquisa (empresas, departamentos) são armazenadas em cache, pois são usadas em várias junções. Cache no início do pipeline – Os dados de origem transformados são armazenados em cache imediatamente após o processamento. ❌ Problemas para corrigir Adicionar limpeza de cache – sempre não persuas dados em cache quando concluídos. Verifique a necessidade do cache – alguns caches podem ser exagerados se os dados forem usados apenas duas vezes. Monitore o uso da memória – adicione o log para rastrear os índices de acerto/falta do cache. Regras simples para cache de ETL Quando o cache: depois de transformações caras (funções de janela, junções complexas) pequenos dados de referência usados em vários lugares que você acessará mais de 3 vezes os resultados da leitura de arquivos ao processar várias saídas quando não para cache: os dados usados apenas ou twe) ou mais grandes conjuntos de dados (como renam a cache) (cache de limpeza) (cache). Dados em cache várias vezes result1 = Process1 (CachedData) Result2 = Process2 (CachedData) Result3 = Process3 (CachedData)} Finalmente {CachedData.UnPersist () // Sempre limpe! } Digite gerenciamento de memória do modo de tela cheia de tela cheia: // Verifique o que é o cache Spark.catalog.ListTables (). Show () // Limpe todo o cache, se necessário, Spark.catalog.clearcache () insere o modo de tela full -scache → Cache em finzeiro Cache Cache CACHET APOSTO DA PROJETO APOSTO O MODO DE CACHETRA PROJETO APENAS SEBTROS DE PROJETO DATACTS → Usado em múltiplas tabela grava carimbos finais → cache porque escritos em várias tabelas relacionadas esse padrão faz sentido, mas a adição de limpeza o tornaria perfeito: Def ProcessWithcleanUp (Spark: SparkSession): Unit = {val Sellosds = SellossourCetransformer.procesaultImossellosActivoSporfechorporpore (SellosDF). EmpresaTransformer.transformEmpresas(sellosDS).cache() try { // Process everything processEmpresas(empresasDS) processSellos(sellosDS, empresasDS) } finally { // Cleanup sellosDS.unpersist() empresasDS.unpersist() } } Enter fullscreen mode Exit fullscreen mode Remember: Cache smart, clean up always!
Fonte
