[EMPERADOR] - Ransomware Victim: AB InBev - https://www.redpacketsecurity.com/emperador-ransomware-victim-ab-inbev/
#emperador #dark_web #data_breach #OSINT #ransomware #threatintel #tor
Search
900 results for “data_diving”
-
RRS Sir David Attenborough Webcam via https://www.bas.ac.uk/data/our-data/images/webcams/rrs-sir-david-attenborough-webcam/
Current location: https://www.vesselfinder.com/vessels/details/9798222
#RRSSirDavidAttenborough #boat #view #webcam #BoatyMcBoatface
-
https://www.europesays.com/unitedstates/64870/ Trump Wants To Force Data Centers To ‘Make Their Own Electricity.’ Deregulation Would Work Better. #401k #Business #BusinessNews #Economy #Energy #Energy&Utilities #finance #FinancialInformation #Investing #InvestmentTools #Investor #MarketNews #mortgage #MutualFunds #PersonalFinance #quote #RealEstate #Retirement #Stock #StockResearch #StockValuation #stocks #SuzeOrman #tax #TrackPortfolio #utilities
-
https://www.europesays.com/people/278522/ California signs laws to regulate data centers – Scot Scoop News #GavinNewsom
-
https://www.europesays.com/unitedstates/64820/ LSEG confirms $3.5 billion talks to buy credit data firm Octus #Bonds #Bonds&InterestRates #CoreWeaveCreditDefaultSwapSpike #InterestRates #LSEG #LSEGAcquisitionOfOctusCreditDataFirm #Octus #OctusAcquisitionPrice$35Billion #Permira #PrivateCreditDataMarket2026 #PrivateCreditMarketDataTrackingPlatform
-
[ANUBIS] - Ransomware Victim: Newcomer Cremations, Funerals & Receptions - https://www.redpacketsecurity.com/anubis-ransomware-victim-newcomer-cremations-funerals-receptions/
#anubis #dark_web #data_breach #OSINT #ransomware #threatintel #tor
-
Male performer in a sensor suit walks across a spacious motion capture stage while a technician monitors digital tracking data.
-
Wolves Descend on Finnish Villages After Google Hacked Down 1,300 Acres of Habitat to Make Room for AI Data Centers
"We had wolves coming into the village because all the wild animals moved out of the forest."
https://futurism.com/future-society/wolves-finland-google-ai-data-centers -
https://www.europesays.com/3330078/ Trump AI push faces voter backlash over data centers: CNBC survey #AmazonComInc #ArtificialIntelligence #BreakingNews:Economy #BreakingNews:Politics #BusinessNews #China #Data #DonaldJTrump #DonaldTrump #Economy #elections #GovernmentAndPolitics #MidTermElections #Politics #SocialIssues #USRepublicanParty
-
RRS Sir David Attenborough Webcam via https://www.bas.ac.uk/data/our-data/images/webcams/rrs-sir-david-attenborough-webcam/
Current location: https://www.vesselfinder.com/vessels/details/9798222
#RRSSirDavidAttenborough #boat #view #webcam #BoatyMcBoatface
-
https://www.europesays.com/unitedstates/64294/ US employment data: What to expect from September’s jobs report #AIJobs #data #EconomicData #Economy #FedInterestRates #FederalReserve #SeptemberEmploymentReport #SeptemberJobsReport #USConstructionJobs #USEconomy #USEmploymentData #USJobGrowth #USJobsReport #USLabourMarket #USManufacturingJobs #USNonfarmPayrolls #USUnemploymentRate #USWageGrowth
-
Hydrilla growth in Lake Austin plateaus
A city of Austin memo sent out Thursday shared new data, showing that an invasive species has stopped spreading in Lake Austin.
https://www.kxan.com/news/local/austin/hydrilla-growth-in-lake-austin-plateaus/
#Austin #Instagram #Local #News #TopStories -
@annex is presenting the SpiceyPy library, which can access spacecraft and planetary ephemeris data with Python. #pybeach #pybeach2026
-
[LAMASHTU] - Ransomware Victim: Vins Viallet - https://www.redpacketsecurity.com/lamashtu-ransomware-victim-vins-viallet/
#lamashtu #dark_web #data_breach #OSINT #ransomware #threatintel #tor
-
[QILIN] - Ransomware Victim: Castle Howard Estate - https://www.redpacketsecurity.com/qilin-ransomware-victim-castle-howard-estate/
#qilin #dark_web #data_breach #OSINT #ransomware #threatintel #tor
-
[QILIN] - Ransomware Victim: Heber City, UT - https://www.redpacketsecurity.com/qilin-ransomware-victim-heber-city-ut/
#qilin #dark_web #data_breach #OSINT #ransomware #threatintel #tor
-
No Kings: Vote Early was the largest early voter activation in US history. Preliminary data also shows early voting surged by 51% over the same Saturday in the last midterms) in zip codes with an event compared to a 19% increase in zip codes without an event.
-
https://www.europesays.com/unitedstates/63804/ Canada Cannabis Sales Reach New High in August 2026 #data #EconomicData #Economy #sales
-
Server-side tracking still needs consent, iubenda tells marketers: Moving tags to a server changes where data travels, not the GDPR and ePrivacy duty to ask first, per iubenda's Oct 23 guide. Its own product is waitlisted. https://ppc.land/server-side-tracking-still-needs-consent-iubenda-tells-marketers/ #ServerSideTracking #DataPrivacy #GDPR #ePrivacy #DigitalMarketing
-
Nos artigos anteriores construímos uma visão cada vez mais completa do Apache Spark.
Passamos por:
Data
↓
Partitions
↓
Tasks
↓
Executors
↓
Shuffle
↓
Joins
↓
Spark SQL
↓
Catalyst
↓
Physical PlanMas existe um recurso atravessando praticamente todas essas etapas:
memória.
Quando comecei a estudar problemas de memória no Spark, era tentador resumir tudo a:
OutOfMemory
↓
aumentar RAMHoje eu vejo esse raciocínio como incompleto.
Um problema de memória pode estar relacionado a:
Driver
Executors
Partitions
Shuffle
Broadcast
Cache
Serialization
Garbage Collection
Python workers
Off-heap/native memory
Memory OverheadE aumentar memória sem descobrir qual desses componentes está causando o problema pode apenas tornar um Job caro antes de ele falhar novamente.
A pergunta correta não é:
Quanto de memória devo adicionar?
É:Quem está consumindo memória, por quê, e em qual parte da arquitetura?
1. Memória em uma aplicação Spark
Vamos voltar à arquitetura básica:DRIVER
│
▼
Cluster Manager
│
┌─────────┼─────────┐
▼ ▼ ▼
Executor 1 Executor 2 Executor 3Temos dois contextos que precisam ser diferenciados imediatamente:
Driver Memory
e:
Executor Memory
Essa distinção é fundamental.
Porque:
Driver OOM
e:
Executor OOM
podem ter causas completamente diferentes.
2. Driver Memory
O Driver coordena a aplicação.Ele mantém informações relacionadas a:
- aplicação;
- Jobs;
- Stages;
- Tasks;
- scheduling;
- metadados;
- planos de execução;
- resultados retornados ao Driver;
- estado necessário para coordenar a computação.
Conceitualmente:
DRIVER
│
┌──────────────┼──────────────┐
▼ ▼ ▼
Planning Scheduling Metadata
│ │ │
└──────────────┼──────────────┘
▼
ControlIsso significa que o Driver não deveria ser tratado como destino para todo o dataset distribuído.
Esse ponto parece óbvio.
Até alguém executar:
dados = df.collect()
3. O perigo do
collect()
Considere:df.count()
O processamento acontece de maneira distribuída e o resultado retornado é pequeno:
123456789
Agora compare com:
dados = df.collect()
collect()solicita que todos os registros do DataFrame sejam retornados ao Driver.Conceitualmente:
Executor 1 ──────┐
Executor 2 ──────┤
Executor 3 ──────┼──► DRIVER
Executor 4 ──────┤
Executor 5 ──────┘Se o dataset possuir:
500 GB
e o Driver tiver:
8 GB
temos um problema bastante previsível.
O Spark é distribuído.
Mas acabamos de pedir:
Traga tudo para uma única máquina.
4.
collect()não é ruim — o contexto é que importa
Não existe problema em:df.limit(10).collect()
quando sabemos que o resultado será pequeno.
Também existem cenários legítimos em que precisamos trazer pequenas quantidades de dados ao Driver.
O problema é usar
collect()sem compreender:Distributed Dataset
↓
DriverA pergunta antes de um
collect()deveria ser:Qual o volume máximo que pode voltar para o Driver?
Essa pergunta evita muitos problemas.
5. Outros caminhos para sobrecarregar o Driver
collect()é o exemplo mais conhecido, mas não é o único.Problemas de Driver também podem aparecer com:
- resultados excessivamente grandes;
- estruturas locais gigantes;
- excesso de metadados;
- quantidade extrema de Tasks;
- operações que materializam dados no processo do Driver;
- código Python executado localmente;
- determinadas operações de visualização ou conversão.
Por exemplo:
pdf = df.toPandas()
merece atenção.
O resultado precisa caber na memória do processo que recebe esse DataFrame local.
Ou seja:
Spark DataFrame distribuído
↓
toPandas()
↓
DataFrame local
↓
DRIVERSe os dados forem grandes, temos novamente uma concentração de memória.
6. Executor Memory
Agora vamos para os Executors.Eles executam as Tasks.
Conceitualmente:
Executor
│
├── Task 1
├── Task 2
├── Task 3
└── Task 4Durante a execução, memória pode ser necessária para:
- processamento;
- agregações;
- joins;
- sorting;
- shuffle;
- estruturas intermediárias;
- cache;
- dados serializados;
- execução de código;
- componentes fora do heap JVM.
É aqui que começam vários problemas clássicos.
7. Uma partição vira trabalho para uma Task
Da Parte 3:Em uma determinada Stage, cada partição normalmente corresponde ao trabalho de uma Task.
Então existe uma conexão direta:Partition
↓
Task
↓
Memory pressureImagine:
Partition 1 → 200 MB
Partition 2 → 180 MB
Partition 3 → 220 MB
Partition 4 → 18 GBA Task responsável pela quarta partição terá um perfil completamente diferente das demais.
Podemos observar:
Task 1 → OK
Task 2 → OK
Task 3 → OK
Task 4 → Memory PressureTalvez o problema não seja:
Executor com pouca memória.
Talvez seja:Uma partição absurdamente maior que as outras.
8. Particionamento e memória são inseparáveis
Imagine um dataset de:1 TB
distribuído em:
10 partitions
Simplificando muito:
≈ 100 GB por partition
Agora considere:
1000 partitions
Teríamos algo mais próximo de:
≈ 1 GB por partition
Isso não significa que uma Task precise manter toda a partição simultaneamente em memória.
Mas o exemplo mostra uma relação importante:
O tamanho e a distribuição das partições influenciam diretamente a pressão de memória das Tasks.
É por isso que simplesmente aumentarspark.executor.memorypode esconder a causa real.
9. Execution Memory
Durante operações como:df.groupBy("customer_id").sum("value")
Spark precisa de memória para executar estruturas intermediárias.
Também em:
df.orderBy("timestamp")
ou em determinados joins.
Podemos pensar conceitualmente:
Executor Memory
│
├── Execution
│ │
│ ├── Shuffle
│ ├── Join
│ ├── Sort
│ └── Aggregation
│
└── Storage
│
├── Cached Data
└── Persisted DataNo Spark moderno, execution e storage participam de um modelo de gerenciamento de memória integrado.
Isso é importante porque a memória disponível não deve ser imaginada como caixas totalmente independentes e rígidas em todos os momentos.
10. Storage Memory
Agora imagine:df.cache()
Quando o DataFrame é materializado, Spark pode manter partições para reutilização.
Conceitualmente:
Executor
│
├── Execution Memory
│
└── Storage Memory
│
├── Partition A
├── Partition B
└── Partition CIsso pode ser extremamente útil.
Se o mesmo dataset caro for utilizado várias vezes:
Expensive computation
↓
CACHE
↓
┌─────┼─────┐
▼ ▼ ▼
Use 1 Use 2 Use 3evitamos recalcular repetidamente a mesma linhagem.
Mas cache também custa memória.
11.
cache()não significa "deixe rápido"
Esse é outro anti-pattern comum:df.cache()
ser utilizado como se significasse:
optimize(df)
Não significa.
Imagine um DataFrame de:
800 GB
que será utilizado apenas uma vez.
Fazer cache pode simplesmente:
- consumir memória;
- provocar eviction;
- aumentar pressão sobre o Executor;
- competir com execution memory;
- não trazer benefício relevante.
Cache faz mais sentido quando existe reuso.
Por exemplo:
base = transformacao_cara(df)
base.cache()
resultado_a = base.groupBy("estado").count()
resultado_b = base.groupBy("produto").sum("valor")
resultado_c = base.filter("status = 'ACTIVE'")Agora existe um motivo claro:
Expensive Base
↓
CACHE
↓
┌────┼────┐
▼ ▼ ▼
A B C12. Cache também é Lazy
Considere:df.cache()
Isso não significa necessariamente:
Neste instante, todas as partições foram computadas e armazenadas.
A materialização ocorre quando uma Action força a computação.Por exemplo:
df.cache()
df.count()
Agora temos:
cache()
↓
mark for persistence
↓
count()
↓
compute partitions
↓
store according to persistence strategyLazy evaluation continua presente.
13.
persist()
Além de:df.cache()
podemos trabalhar com:
df.persist()
e escolher estratégias de persistência adequadas ao contexto.
Conceitualmente, a persistência pode envolver combinações de:
Memory
Disk
Serialization
ReplicationA escolha depende de fatores como:
- tamanho;
- frequência de reuso;
- custo de recomputação;
- memória disponível;
- tolerância a I/O.
Novamente, não existe uma configuração universalmente melhor.
14. E quando a memória não é suficiente?
Agora chegamos a algo que apareceu na Parte 4:Spill
Imagine uma Task realizando:Sort
ou:
Aggregation
ou processamento relacionado a:
Shuffle
Ela utiliza estruturas em memória.
Mas a quantidade necessária ultrapassa o que pode ser mantido eficientemente ali.
Então parte dos dados pode ser enviada para disco.
Conceitualmente:
Task
↓
Memory
↓
Memory pressure
↓
Spill
↓
DiskDepois:
Disk
↓
Read
↓
Continue processingIsso permite que determinadas operações continuem mesmo quando tudo não cabe simultaneamente em memória.
Mas existe um preço.
15. Spill troca memória por I/O
Compare:Memory
↓
CPUcom:
Memory
↓
Disk Write
↓
Disk Read
↓
CPUDisco normalmente é muito mais lento do que memória.
Então grandes volumes de spill podem transformar:
Job
em:
Job lento
Mesmo sem ocorrer um OutOfMemory.
Essa é uma lição importante:
Uma aplicação pode estar sofrendo de pressão de memória sem necessariamente falhar por OOM.
Ela pode simplesmente ficar muito mais lenta.
16. Shuffle + Memory + Spill
Agora conectamos vários artigos.Considere:
resultado = (
vendas
.groupBy("customer_id")
.sum("valor")
)Podemos ter:
Partitions
↓
Partial Aggregation
↓
Shuffle Write
↓
Network
↓
Shuffle Read
↓
Aggregation
↓
Memory pressure
↓
Spill
↓
DiskAgora um simples:
groupBy()
ganha uma interpretação completamente diferente.
17. Data Skew volta novamente
Imagine:P1 = 200 MB
P2 = 210 MB
P3 = 190 MB
P4 = 15 GBDurante uma agregação:
P1 → OK
P2 → OK
P3 → OK
P4 → Spill → Spill → SpillOu pior:
P4 → OutOfMemory
A reação inicial pode ser:
Aumentar executor memory.
Talvez funcione.Mas talvez a pergunta correta seja:
Por que existe uma partição de 15 GB quando as demais possuem aproximadamente 200 MB?
Estamos novamente diante de:Data Skew
A causa é distribuição.
O sintoma aparece na memória.
18. OutOfMemory não é um único problema
Quando alguém diz:"Spark deu OOM."
Ainda sabemos muito pouco.Precisamos perguntar:
Onde?
Por exemplo:
Driver OOM?
ou:
Executor OOM?
ou pressão fora do heap/container?
Também precisamos perguntar:
Em qual Stage?
Em qual operação?
Em todas as Tasks?
Em uma única Task?
Depois de um Shuffle?
Durante Broadcast?
Durante collect()?
Essas perguntas mudam completamente a investigação.
19. Um Driver OOM pode indicar problema de arquitetura
Imagine:dados = df.collect()
sobre um dataset enorme.
Podemos aumentar:
spark.driver.memory
de:
4 GB
para:
16 GB
Depois:
32 GB
Depois:
64 GB
Talvez o Job finalmente funcione.
Mas a pergunta continua:
Por que estamos trazendo um dataset distribuído gigantesco para um único processo?
Aumentar memória resolveu o sintoma.Talvez não tenha resolvido o design.
20. Executor OOM também pode esconder outro problema
Agora imagine:Executor OOM
A reação:
spark.executor.memory
8 GB → 16 GBMas talvez exista:
uma partition = 40 GB
Ou:
join skewed
Ou:
broadcast excessivo
Ou várias Tasks concorrentes disputando recursos.
Ou consumo significativo fora do heap principal.
Então:
Executor OOM não significa automaticamente que o Executor precisa apenas de mais heap.
21.
spark.executor.memory
Uma configuração conhecida é:spark.executor.memory
Ela define a quantidade de memória heap disponibilizada ao processo Executor JVM.
Por exemplo:
--executor-memory 8g
Mas existe uma armadilha conceitual importante:
A memória total necessária por um Executor não é necessariamente igual ao valor de
spark.executor.memory.
Existe memória utilizada fora desse heap.E isso nos leva diretamente ao tema do material original que estudei:
Memory Overhead
22. O que é Memory Overhead?
Uma aplicação Spark não utiliza memória apenas para o heap principal da JVM.Podemos pensar de forma simplificada:
Executor Container / Process Environment
│
├── JVM Heap
│
│ └── spark.executor.memory
│
└── Additional / Non-Heap Memory
│
├── JVM overhead
├── native memory
├── Python processes
├── direct buffers
└── other runtime overheadÉ essa segunda região que torna
memoryOverheadtão importante.Dependendo do ambiente e do workload, um Executor pode morrer mesmo quando aparentemente existe heap suficiente.
23. Um exemplo conceitual
Imagine uma configuração:Executor Heap
8 GBIsso não significa necessariamente:
Executor total
=
8 GBO processo também precisa de espaço para outras necessidades.
Podemos pensar:
Container / Pod / Executor allocation
┌───────────────────────────────┐
│ │
│ JVM Heap │
│ spark.executor.memory │
│ │
├───────────────────────────────┤
│ │
│ Memory Overhead │
│ │
│ Native / Python / Direct / │
│ JVM non-heap / other │
│ │
└───────────────────────────────┘Se a região adicional for insuficiente, o processo pode exceder os limites impostos pelo gerenciador de recursos.
24. Por que isso aparece muito com PySpark?
Em PySpark existe uma característica importante.Nosso código Python não transforma a JVM inteira em Python.
Existe interação entre:
JVM
↕
Python workerConceitualmente:
Executor JVM
│
├── Spark execution
│
└── Python worker
│
└── Python codeEsses processos também consomem memória.
Dependendo do workload, bibliotecas e operações utilizadas, isso pode se tornar relevante para o consumo total do Executor.
Portanto, em PySpark precisamos olhar além de:
JVM Heap
25. Memory Overhead no material histórico
Uma das anotações que motivou este capítulo tratava especificamente de problemas dememoryOverhead.Esse tipo de problema continua conceitualmente relevante.
O que mudou ao longo dos anos foram:
- versões do Spark;
- nomes e comportamento de determinadas configurações;
- resource managers;
- defaults;
- cálculo automático de overhead;
- integração com containers;
- Kubernetes;
- execução Python;
- mecanismos internos de memória.
Por isso não considero uma boa prática pegar uma configuração antiga e simplesmente reproduzi-la hoje.
O conceito continua válido.
A configuração precisa ser analisada no contexto da versão e do ambiente atuais.
26. Heap vs. Off-Heap vs. Overhead
Uma simplificação útil é:PROCESS MEMORY
│
├── JVM Heap
│
├── JVM Non-Heap
│
├── Direct / Native Memory
│
├── Python Worker Memory
│
└── Runtime OverheadIsso é mais próximo da realidade do que pensar:
memory = spark.executor.memory
Quando um container é encerrado por ultrapassar limite de memória, precisamos descobrir qual parte do consumo cresceu.
27. Garbage Collection
Agora vamos entrar em outro sintoma importante:GC
A JVM gerencia automaticamente memória de objetos.Objetos são criados:
Objects
↓
HeapDepois deixam de ser necessários.
O Garbage Collector precisa recuperar esse espaço.
Em um cenário saudável:
Application Work ███████████████████
GC █
Mas sob forte pressão podemos encontrar algo mais próximo de:
Application ███████
GC █████████████
Ou seja:
A aplicação passa tempo demais tentando gerenciar memória em vez de processar dados.
28. GC alto é sintoma
Assim como OOM, GC excessivo não deveria gerar automaticamente:Aumente a heap.
Talvez tenhamos:- objetos demais;
- partições grandes;
- agregações pesadas;
- estruturas intermediárias enormes;
- cache excessivo;
- serialização inadequada;
- concorrência excessiva por Executor.
Precisamos descobrir por que a memória está sob pressão.
29. Mais cores por Executor também afetam memória
Imagine:Executor
8 coresDependendo da configuração, várias Tasks podem executar simultaneamente nesse Executor.
Conceitualmente:
Executor Memory
│
┌────┼────┬────┬────┬────┐
▼ ▼ ▼ ▼ ▼ ▼
T1 T2 T3 T4 T5 ...Cada Task pode precisar de memória.
Então existe uma relação:
mais Tasks concorrentes por Executor
↓
mais competição pela memória disponívelIsso mostra por que tuning não deveria analisar:
executor memory
isoladamente.
Precisamos olhar para:
Executor Memory
+
Executor Cores
+
Partition Size
+
Task Behavior30. Executors gigantes também não são automaticamente melhores
Poderíamos pensar:1 Executor
64 cores
256 GB RAMParece poderoso.
Mas Executors gigantes podem trazer trade-offs relacionados a:
- concorrência;
- garbage collection;
- blast radius de falha;
- utilização;
- scheduling;
- memória compartilhada entre muitas Tasks.
No outro extremo:
64 Executors
1 core
4 GBtambém possui trade-offs.
Não existe um tamanho universal.
Precisamos equilibrar:
cores
memory
parallelism
partition size
workload
cluster manager31. Broadcast também consome memória
Na Parte 5 vimos:from pyspark.sql.functions import broadcast
resultado = grande.join(
broadcast(pequena),
"id"
)A estratégia pode evitar um shuffle grande.
Mas existe um custo:
Small Table
↓
Broadcast
┌──┼──┐
▼ ▼ ▼
E1 E2 E3Cada Executor precisa conseguir trabalhar com a estrutura transmitida.
Se tentarmos broadcast de algo grande demais, podemos criar pressão significativa de memória.
Novamente:
Network optimization
↕
Memory costSistemas distribuídos são cheios de trade-offs.
32. Cache também compete por recursos
Imagine:df_a.cache()
df_b.cache()
df_c.cache()
df_d.cache()Pode parecer:
Quanto mais cache, melhor.
Mas:Cache A
Cache B
Cache C
Cache D
↓
Storage Pressure
↓
Eviction / recomputation / resource competitionCache deveria ser uma decisão baseada em:
reuse frequency
×
recomputation cost
×
available resourcese não um reflexo automático.
33.
unpersist()
Se um dataset não será mais reutilizado, podemos liberar sua persistência:df.unpersist()
Isso comunica:
Não preciso mais manter essas partições persistidas.
Em pipelines longos isso pode ser importante.Por exemplo:
Phase A
↓
cache intermediate
↓
reuse several times
↓
phase completed
↓
unpersist
↓
free resources for Phase BGerenciamento de memória também faz parte do design do pipeline.
34. O Spark UI volta a ser essencial
Se existe problema de memória, não quero começar alterando configurações.Quero observar.
No Spark UI e métricas relacionadas, procuro sinais como:
Task Duration
GC Time
Shuffle Read
Shuffle Write
Spill
Storage
Executor behavior
Failed Tasks
SkewTambém observo logs.
A pergunta é:
O que aconteceu antes da falha?
35. Um padrão de investigação
Imagine:Job falhou
↓
Executor lost
↓
Memory-related errorMeu raciocínio começaria assim:
Qual Stage?
↓
Qual operação?
↓
Join?
Aggregation?
Sort?
UDF?
Cache?Depois:
Todas as Tasks falharam?
↓
ou apenas algumas?Se apenas algumas:
Possível skew?
Depois:
Qual tamanho das partitions?
Quanto shuffle?
Quanto spill?
Quanto GC?Só então:
Heap insuficiente?
Overhead insuficiente?
Particionamento ruim?
Broadcast inadequado?
Concorrência excessiva?36. Caso 1 — Driver morrendo
Sintoma:Driver OutOfMemory
Código:
dados = df.collect()
Dataset:
120 GB
Driver:
8 GB
Diagnóstico provável:
Distributed Data
↓
collect()
↓
Single Process
↓
OOMSolução arquitetural:
Não coletar o dataset inteiro.
Talvez:df.write.parquet(
"/data/output"
)ou continuar o processamento distribuído.
A solução principal não é necessariamente:
8 GB → 128 GB
37. Caso 2 — Uma Task morre repetidamente
Sintoma:Stage 12
199 Tasks → OK
1 Task → FAILIsso é extremamente informativo.
Talvez tenhamos:
Data Skew
ou uma partição muito maior.
Se aumentarmos memória de todos os Executors:
Cluster cost ↑
para resolver uma única partição anormal, talvez estejamos atacando o lugar errado.
Precisamos investigar a distribuição.
38. Caso 3 — Todas as Tasks sofrem Spill
Imagine:Task 1 → heavy spill
Task 2 → heavy spill
Task 3 → heavy spill
Task 4 → heavy spill
...Agora talvez tenhamos um problema sistêmico.
Possíveis causas:
Partitions muito grandes
Memory insuficiente
Join pesado
Sort pesado
Aggregation pesada
Task concurrencyNesse cenário, ajustar recursos pode realmente fazer parte da solução.
Mas ainda precisamos medir.
39. Caso 4 — OOM depois de Broadcast
Imagine que:Job funcionava
e alguém adicionou:
broadcast(dim)
Agora Executors começam a morrer.
Pergunta:
Qual o tamanho real de dim?
Talvez:
"small table"
tenha crescido.
Ontem:
50 MB
Hoje:
6 GB
Uma otimização válida no passado pode se tornar um problema quando os dados mudam.
Isso é importante:
Performance depende também da evolução dos dados.
40. Caso 5 — PySpark e memória externa ao heap
Imagine:spark.executor.memory
aparentemente confortável.
Mas containers continuam sendo encerrados por memória.
Agora precisamos olhar para:
JVM Heap
+
Python workers
+
Native memory
+
Direct buffers
+
Other overheadÉ exatamente nesse tipo de cenário que compreender
memoryOverheaddeixa de ser detalhe e passa a ser parte do diagnóstico.
41. Não ajuste
memoryOverheadàs cegas
Se um Executor morre por ultrapassar limites externos ao heap, aumentar overhead pode ser apropriado.Mas ainda precisamos perguntar:
Por que esse consumo existe?
Pode ser:
- Python;
- bibliotecas nativas;
- buffers;
- comportamento da JVM;
- volume de dados;
- operação específica.
A configuração correta depende do workload e do ambiente.
Por isso evito recomendações como:
sempre configure X GB
ou:
sempre use Y%
sem contexto.
Defaults e comportamentos também evoluem entre versões.
42. Memória em Kubernetes
Em ambientes containerizados, a questão fica ainda mais visível.Podemos pensar:
Kubernetes Pod
│
└── Executor
│
├── JVM Heap
├── Non-Heap
├── Native
├── Python
└── OverheadO Pod possui limites.
Não basta a JVM achar que possui heap suficiente.
O consumo total do processo e componentes associados precisa respeitar os recursos disponíveis.
Esse é um dos motivos pelos quais problemas modernos de Spark precisam ser analisados também no nível da infraestrutura.
43. Memória em YARN
Em ambientes YARN, existe raciocínio semelhante.O Executor executa dentro de recursos controlados pelo gerenciador do cluster.
Historicamente, muitos erros de
memoryOverheadficaram conhecidos justamente em ambientes onde o container ultrapassava seu limite mesmo quando a heap configurada parecia aceitável.O princípio permanece:
JVM Heap
≠
Total Process Memory44. A configuração depende do ambiente
Hoje Spark pode rodar em diferentes contextos:Standalone
YARN
Kubernetes
Managed Platforms
Cloud ServicesIsso significa que recomendações de memória precisam considerar:
- Spark version;
- cluster manager;
- container limits;
- JVM;
- Python;
- workload;
- plataforma gerenciada.
Uma configuração copiada de um artigo antigo pode estar:
correta historicamente
e:
inadequada atualmente
ao mesmo tempo.
Esse é exatamente o tipo de cuidado que estou aplicando ao revisitar meu material antigo nesta série.
45. Um modelo mental melhor para OOM
Em vez de:OOM
↓
More Memoryprefiro:
OOM
│
┌──────────┴──────────┐
▼ ▼
Driver? Executor?
│ │
▼ ▼
collect()? Which Stage?
toPandas()? │
metadata? ▼
Which Operation?
│
┌──────────┼──────────┐
▼ ▼ ▼
Skew Shuffle Broadcast
│ │ │
└──────────┼──────────┘
▼
Partition Size
│
▼
Heap or Overhead?
│
▼
Root CauseEsse modelo evita tratar todos os erros de memória como iguais.
46. Performance tuning começa com observabilidade
Imagine dois engenheiros.O primeiro vê:
OutOfMemoryError
e imediatamente altera:
spark.executor.memory
O segundo investiga:
Stage
Tasks
Partition distribution
Shuffle
Spill
GC
Executor logs
Physical plan
Data volumeO segundo talvez leve alguns minutos a mais antes de alterar a configuração.
Mas a chance de resolver a causa real é muito maior.
Essa é uma diferença importante entre:
configuration tuning
e:
performance engineering
47. Um checklist para problemas de memória
Quando encontro um problema de memória em Spark, quero responder:- O erro aconteceu no Driver ou Executor?
- Qual Stage estava executando?
- Qual operação estava acontecendo?
- Existe
collect()? - Existe
toPandas()? - Existe broadcast?
- Existe cache excessivo?
- As partições estão equilibradas?
- Existe data skew?
- Qual o tamanho das maiores Tasks?
- Existe Shuffle?
- Quanto?
- Existe Spill?
- Quanto?
- Quanto tempo está sendo gasto em GC?
- Todas as Tasks sofrem ou apenas algumas?
- Existem Python workers?
- Existe consumo nativo relevante?
- O limite do container está sendo ultrapassado?
- O problema é heap ou overhead?
- A configuração corresponde à versão e ao cluster manager utilizados?
Só depois:
Qual configuração preciso alterar?
48. O que eu evitaria fazer automaticamente
Se o Job estiver lento ou falhando, eu evitaria começar por:dobrar executor memory
ou:
dobrar driver memory
ou:
aumentar memoryOverhead arbitrariamente
ou:
cachear tudo
ou:
reduzir o número de partitions sem medir
ou:
aumentar o cluster
Todas essas ações podem ser válidas.
Mas nenhuma delas deveria substituir diagnóstico.
49. Memória, performance e custo
Em cloud, existe ainda outra dimensão.Imagine:
Executor Memory
8 GBe simplesmente dobramos para:
16 GB
em dezenas ou centenas de Executors.
Talvez o Job fique estável.
Mas talvez tenhamos acabado de aumentar recursos para compensar:
Data Skew
ou:
repartition ruim
ou:
join inadequado
ou:
cache desnecessário
Então temos:
Problema arquitetural
↓
Mais infraestrutura
↓
Maior custo
↓
Problema mascaradoPerformance tuning também é FinOps.
50. A conexão entre tudo que vimos até aqui
Agora podemos montar uma visão muito mais completa:DATA
│
▼
PARTITIONS
│
▼
TASKS
│
▼
EXECUTORS
│
┌───────────┼───────────┐
▼ ▼ ▼
Memory CPU Network
│ │
▼ ▼
Aggregation Shuffle
│ │
└───────────┬───────────┘
▼
Spill
│
▼
Disk
│
▼
Performance
│
▼
CostAgora adicione:
Data Skew
e podemos gerar:
Uneven Partition
↓
Huge Task
↓
Memory Pressure
↓
Spill / GC
↓
Slow Task
↓
Straggler
↓
Slow StageIsso mostra por que os capítulos anteriores estavam conectados.
51. A principal lição deste capítulo
Se eu pudesse resumir memória no Spark em uma frase:Problemas de memória frequentemente são sintomas de como os dados e a computação foram distribuídos.
Nem sempre.Às vezes realmente precisamos de mais memória.
Mas antes de aumentar recursos, quero saber:
Quem está consumindo?
↓
Onde?
↓
Durante qual operação?
↓
Por quê?Só então:
Architecture
+
Configuration
+
Resourcesentram na solução.
52. Como penso hoje
Meu modelo mental deixou de ser:Spark OOM
↓
Increase Memorye passou a ser:
Spark OOM
↓
Driver or Executor?
↓
Heap or Overhead?
↓
Which Stage?
↓
Which Task?
↓
Which Operation?
↓
Partition Size?
↓
Skew?
↓
Shuffle?
↓
Spill?
↓
Broadcast?
↓
Cache?
↓
Python / Native Memory?
↓
Root Cause
↓
Then TuneEsse raciocínio é muito mais útil do que decorar valores de configuração.
Próximo artigo
Agora entendemos:Partitions
↓
Tasks
↓
Memory
↓
Shuffle
↓
SpillMas existe outro conceito fundamental que apareceu desde os primeiros artigos:
Lineage.
Quando uma partição é perdida, como Spark sabe reconstruí-la?
Por que RDD significa:
Resilient Distributed Dataset
?
Como Spark obtém tolerância a falhas sem simplesmente replicar toda computação intermediária?
E o que acontece quando a linhagem fica grande demais?
No próximo artigo vamos explorar:
- RDD Lineage;
- DAG;
- fault tolerance;
- recomputation;
- cache vs. recomputation;
- checkpoint;
- persistência;
- falha de Executor;
- recuperação de partições;
- por que Spark é "resilient";
- e como essas ideias evoluíram nas APIs modernas.
Vamos partir deste modelo:
Source
↓
Map
↓
Filter
↓
Join
↓
Aggregate
↓
Resultpara enxergar algo mais profundo:
LINEAGE
│
▼
Source → Transform → Transform → Shuffle → Result
│ │ │
└──────────┴──────────┘
│
information needed
for recomputationEssa é uma das ideias fundamentais que fizeram o Spark ser Spark.
← Parte 6: Spark SQL e DataFrames — do código ao plano de execução
Próximo: Parte 8 — RDD Lineage e tolerância a falhas: como o Spark se recupera quando algo dá errado#cluster #spark #python #bigdata #software #coding #development #engineering #inclusive #community
Como aprendi Apache Spark — Parte 7: Memória — Executors, Driver, Cache, Spill e OutOfMemory -
In today's email:
Google uses my SIM card to get my phone number and adds it to the data profile they've created on me.
Another reminder that #Google doesn't get #consent.
If you do not want Google to "obtain your number from your carrier" then follow these steps:
1: Stop the monitoring service by following the listed steps.
2: Remove the phone number(s) they have already retrieved.
3: Never trust Google to do what is right.
-
https://www.europesays.com/3329343/ KhetiBuddy: How Vinay Nair Is Connecting Farm Data With Global Food Supply Chains Through Verdnt #FoodNetworks #FoodSecurity #GlobalFood #GlobalFoodNetworks #GlobalFoodSecurity
-
[QILIN] - Ransomware Victim: SLTN Inter Access - https://www.redpacketsecurity.com/qilin-ransomware-victim-sltn-inter-access/
#qilin #dark_web #data_breach #OSINT #ransomware #threatintel #tor
-
[EMPERADOR] - Ransomware Victim: Frommann Energie GmbH - https://www.redpacketsecurity.com/emperador-ransomware-victim-frommann-energie-gmbh/
#emperador #dark_web #data_breach #OSINT #ransomware #threatintel #tor
-
[EMPERADOR] - Ransomware Victim: Phoenix S&S GmbH - https://www.redpacketsecurity.com/emperador-ransomware-victim-phoenix-s-s-gmbh/
#emperador #dark_web #data_breach #OSINT #ransomware #threatintel #tor
-
RE: https://eupolicy.social/@edri/117483818077500321
Instead of enforcing GDPR to protect European citizens' personal data and the sovereign management of European states, free of foreign influence, the EU Council and Commission and working to remove GDPR protection of personal data when it is collected and acquired by parties who will claim it is for development of Artificial Intelligence.
There will be no meaningful protection left afterwards.
-
Big Tech strikes again! 🌲 #Google decided that the best way to boost their data center was to sacrifice a forest the size of a small country. Who knew you could "optimize" your search results by becoming a lumberjack? 🤦♂️
https://nypost.com/2026/10/24/business/google-illegally-tore-down-250k-trees-for-finland-data-center-infuriating-locals-report/ #BigTech #EnvironmentalImpact #Lumberjack #DataCenters #HackerNews #ngated -
https://www.europesays.com/unitedstates/63462/ Champaign County Board to consider data center tax policy, NDA prohibition and referendum discussion #FederalPolicy #Policy
