Cloud Server
Apache Spark em Cloud Server: como dimensionar
Aprenda a dimensionar Apache Spark em Cloud Server, com CPU, RAM, disco, rede e storage adequados para clusters de ETL, SQL e machine learning na prática.
Resposta direta
Para executar Apache Spark em Cloud Server, comece com uma instância para o driver e pelo menos duas para os executores. Um laboratório funcional pode usar três servidores com 4 vCPUs, 16 GB de RAM e 100 GB de SSD cada. Em produção, 8 a 16 vCPUs e 32 a 64 GB de RAM por worker oferecem uma base mais realista, desde que o tamanho dos arquivos, o volume de shuffle e a concorrência sejam medidos. Prefira executores com 4 ou 5 cores, reserve memória fora do heap e mantenha os dados persistentes em armazenamento de objetos ou distribuído. O disco local rápido deve receber arquivos temporários, enquanto a rede privada precisa suportar a troca de dados entre nós sem atravessar a internet pública.
Esse ponto de partida não substitui um teste com o workload real. Um job que lê 500 GB de Parquet, aplica filtros seletivos e grava um resultado de 20 GB exige uma arquitetura bem diferente de um treinamento de machine learning que mantém centenas de gigabytes em cache. A quantidade de dados lida também não revela sozinha o consumo: joins, agregações, reparticionamentos e funções de janela podem multiplicar o tráfego de shuffle.
Cloud Server facilita criar, substituir e redimensionar nós, mas não torna o Spark tolerante a qualquer falha automaticamente. O driver continua sendo um componente sensível, e os executores precisam acessar dados persistentes fora do disco efêmero. Antes de ampliar o cluster, confira no Spark UI se o gargalo está em CPU, memória, disco, rede ou distribuição desigual das partições. Muitas vezes, corrigir um join mal planejado reduz mais o tempo do job do que dobrar o número de servidores.
Resumo rápido
- Separe driver e executores quando o ambiente deixar de ser apenas um laboratório.
- Use 4 ou 5 cores por executor como ponto inicial, depois ajuste com benchmark.
- Reserve de 10% a 20% da memória para sistema operacional e processos auxiliares.
- Trate SSD ou NVMe local como área temporária para shuffle, spill e cache descartável.
- Armazene datasets persistentes em objeto, HDFS ou outra camada replicada.
- Mantenha os nós na mesma região e, quando possível, na mesma rede privada.
- Monitore Spark UI, CPU, memória, IOPS, throughput, latência e falhas de executor.
Um cluster pequeno para desenvolvimento pode ter um nó principal com 4 vCPUs e 16 GB de RAM, acompanhado de dois workers equivalentes. Essa configuração permite validar ingestões, transformações SQL e jobs de até algumas dezenas de gigabytes, mas não define um limite universal. Formato de arquivo, compressão, número de colunas, cardinalidade e operações de shuffle alteram o consumo. Um CSV de 50 GB, por exemplo, costuma exigir mais CPU e leitura do que um conjunto Parquet bem particionado com o mesmo tamanho lógico.
Para uma equipe que processa centenas de gigabytes por execução, um desenho inicial mais plausível usa três ou quatro workers com 8 vCPUs, 32 GB de RAM e pelo menos 200 GB de SSD rápido por nó. Se o job derrama 600 GB para disco durante um join, 200 GB locais serão insuficientes mesmo que o dataset de entrada tenha apenas 300 GB. O histórico de execuções deve orientar a capacidade.
Também é útil separar três decisões que costumam aparecer misturadas. A primeira é o tamanho de cada servidor. A segunda é a quantidade de executores e cores entregues ao job. A terceira é onde os dados permanecem entre as execuções. Escalar apenas uma dessas camadas pode deslocar o gargalo sem reduzir o tempo total.
Como o Apache Spark distribui o processamento
Driver, executores e gerenciador do cluster
O driver cria o plano de execução, agenda tarefas e acompanha o estado dos executores. Ele não é apenas um painel administrativo. Operações como collect(), conversão para estruturas locais e metadados de um número muito alto de partições podem consumir sua memória. Um driver com 8 GB pode coordenar jobs moderados, mas pode falhar se o código tentar trazer um resultado de 20 GB para um único processo. Nesse caso, aumentar a RAM apenas adia um erro de desenho.
Os executores processam partições, mantêm blocos em cache e produzem dados de shuffle. Em um worker com 16 vCPUs e 64 GB de RAM, criar um único executor com 15 cores parece simples, mas aumenta pausas de coleta de lixo e concentra a perda quando o processo cai. Um ponto inicial mais equilibrado seria três executores com 5 cores, deixando uma vCPU para o sistema, e cerca de 17 GB a 18 GB de heap por executor, além do memory overhead. Esses valores precisam ser ajustados conforme a versão do Spark e o perfil do job.
O gerenciador de cluster pode ser o Spark Standalone, Kubernetes ou YARN. Para uma instalação nova em Cloud Servers, Standalone reduz a quantidade de componentes e funciona bem em clusters dedicados. Kubernetes traz isolamento, agendamento e integração com uma plataforma já existente, mas adiciona rede, volumes, imagens e políticas ao diagnóstico. Se a equipe também avalia processamento contínuo, o artigo sobre Apache Flink em produção ajuda a separar workloads de streaming stateful de pipelines Spark em lote ou Structured Streaming.
VPS tradicional, Cloud Server ou serviço gerenciado
Uma VPS tradicional pode executar Spark, desde que ofereça recursos previsíveis, rede privada e armazenamento adequado. Cloud Server costuma facilitar automação, imagens, redimensionamento e criação de múltiplas instâncias, embora a implementação varie por provedor. Uma cloud instance também pode ter CPU compartilhada, disco remoto ou limites de tráfego. O nome comercial, sozinho, não confirma desempenho consistente.
Serviços gerenciados removem parte da instalação e do ciclo de vida do cluster, mas cobram pela conveniência e limitam algumas escolhas. Cloud Servers fazem sentido quando a equipe precisa controlar versões, bibliotecas, rede e custos operacionais. Esse controle vem acompanhado da responsabilidade por atualizações, segurança, logs, recuperação e testes de falha.
Como dimensionar CPU, RAM e executores
Tamanho dos executores
O dimensionamento deve partir de três medidas: volume processado, concorrência e intensidade de shuffle. Considere um pipeline diário que lê 800 GB de Parquet, filtra os dados, faz um join com uma dimensão de 4 GB e grava 120 GB. Se apenas um job roda por vez, quatro workers com 16 vCPUs e 64 GB de RAM podem formar uma base de teste. Com três jobs simultâneos, o mesmo cluster pode sofrer fila, disputa por disco e expulsão de cache. A capacidade precisa acompanhar o pico, não apenas a média diária.
Executores com 4 ou 5 cores são um ponto inicial comum porque oferecem paralelismo sem criar processos excessivamente grandes. Em quatro workers de 16 vCPUs, reservar uma vCPU por nó deixa 60 cores utilizáveis. Seria possível iniciar 12 executores de 5 cores. Se cada executor receber 18 GB de heap e 4 GB de overhead, o consumo fica em 66 GB por worker para três executores, acima de uma máquina de 64 GB. A conta precisa fechar antes do deploy. Reduzir para dois executores por nó ou usar heap menor evita swap e encerramentos pelo sistema operacional.
Uma configuração inicial poderia usar --executor-cores 5, --executor-memory 20g e --conf spark.executor.memoryOverhead=4g em workers de 64 GB. Isso não garante o melhor resultado. Jobs com Python, serialização pesada, buffers de rede ou bibliotecas nativas podem precisar de overhead maior. Spark SQL com dados bem compactados pode operar com menos.
Memória do heap e memory overhead
A RAM do servidor não pode ser integralmente entregue ao heap Java. Reserve de 10% a 20% para Linux, daemon do cluster, page cache e monitoramento. O memory overhead cobre memória nativa, buffers, processos Python e outras estruturas fora do heap. Quando um executor é encerrado por exceder memória física, aumentar somente spark.executor.memory pode piorar o problema, pois reduz a folga externa.
O paralelismo também precisa acompanhar os cores disponíveis. Como ponto de partida, use duas a quatro tarefas por core ao definir partições de saída ou spark.sql.shuffle.partitions. Um cluster com 60 cores poderia começar entre 120 e 240 partições para um estágio moderado. Para 1 TB de shuffle, apenas 120 partições criariam blocos médios grandes demais. Partições entre aproximadamente 128 MB e 512 MB costumam ser mais administráveis, mas o valor correto depende da operação, da compressão e do armazenamento.
| Perfil inicial | Nós | Recursos por nó | Organização sugerida | Uso provável |
|---|---|---|---|---|
| Laboratório | 3 | 4 vCPUs, 16 GB RAM, 100 GB SSD | 1 driver e 2 workers | Testes, cursos e ETL de dezenas de GB |
| Equipe de dados | 4 | 8 vCPUs, 32 GB RAM, 200 GB SSD rápido | 1 driver e 3 workers | Pipelines recorrentes de 100 GB a 500 GB |
| Produção intensiva | 6 | 16 vCPUs, 64 GB RAM, 500 GB SSD ou NVMe | 2 nós de controle e 4 workers | Jobs concorrentes, shuffle elevado e datasets maiores |
A tabela representa pontos de partida para teste, não limites garantidos. Meça duração, bytes de shuffle, spill, tempo de coleta de lixo e utilização de CPU antes de contratar capacidade permanente.
Disco, armazenamento e rede no cluster
Disco local para shuffle
O Spark usa disco quando os dados não cabem em memória, durante ordenações, agregações, joins e materialização de shuffle. Um job pode ler 300 GB e escrever mais de 1 TB temporariamente, dependendo do plano. Por isso, um worker com 64 GB de RAM e apenas 80 GB de disco pode ficar sem espaço antes de a CPU atingir 50%. Acompanhe Disk Bytes Spilled, Shuffle Write e o uso dos diretórios configurados em spark.local.dir.
SSD reduz latência e atende melhor a acessos aleatórios do que discos magnéticos. NVMe local pode elevar IOPS e throughput, mas seu efeito precisa ser comprovado com benchmark. Se o job passa a maior parte do tempo lendo objetos pela rede, trocar SSD por NVMe não corrige a origem da lentidão. Em workers com dois volumes temporários, é possível configurar diretórios separados, como /mnt/spark1,/mnt/spark2, distribuindo o spill. Os volumes devem ser formatados, montados com opções adequadas e monitorados individualmente.
Arquivos temporários não devem ser tratados como cópia durável. Se uma instância for substituída, o cache e o shuffle local podem desaparecer. O Spark recompõe parte desses dados por meio da linhagem e da repetição de tarefas, mas isso aumenta o tempo e não recupera datasets que só existiam naquele disco.
Armazenamento persistente para dados
Datasets de entrada, checkpoints e saídas devem permanecer em armazenamento de objetos, HDFS replicado ou um sistema distribuído compatível com o ambiente. A análise sobre armazenamento em bloco e objeto na cloud detalha por que volumes em bloco atendem bem ao sistema de arquivos de uma instância, enquanto objetos funcionam melhor como camada durável e desacoplada dos workers.
Para data lakes, Parquet com compressão e particionamento coerente reduz leitura desnecessária. Milhões de arquivos de 20 KB pressionam o driver e o serviço de objetos. Arquivos entre algumas centenas de megabytes costumam produzir um equilíbrio melhor, sujeito ao mecanismo de consulta e ao padrão de atualização. Um job que recebe 10 milhões de eventos pequenos pode compactá-los em arquivos maiores antes das consultas analíticas.
Na rede, mantenha driver, workers e armazenamento na mesma região. Use interfaces privadas para o tráfego interno e verifique limites de throughput por instância. Quatro workers lendo 500 MB/s cada exigem 2 GB/s agregados na camada de dados. Se o storage entrega 600 MB/s ao conjunto, adicionar workers aumenta a contenção. Testes com iperf3, ferramentas do storage e uma amostra do job ajudam a separar gargalos de rede, disco e aplicação.
Arquiteturas práticas para executar Spark
Cluster Standalone
Spark Standalone é uma opção direta para um cluster dedicado. Um desenho básico usa um master, um nó para o driver em modo client ou cluster e dois ou mais workers. Em produção, colocar master e driver na mesma instância economiza recursos, mas amplia o impacto de uma falha. Uma arquitetura mais cuidadosa separa o nó de acesso, os componentes de controle e os workers, além de manter os dados fora dessas máquinas.
Em um laboratório com três Cloud Servers Ubuntu, instale a mesma versão de Java e Spark em todos os nós, configure resolução por DNS privado e restrinja as portas ao segmento interno. O master pode ser iniciado com sbin/start-master.sh, enquanto cada worker usa sbin/start-worker.sh spark://spark-master:7077. Um envio inicial pode seguir este formato:
spark-submit \
--master spark://spark-master:7077 \
--deploy-mode cluster \
--executor-cores 4 \
--executor-memory 12g \
--conf spark.executor.memoryOverhead=3g \
jobs/etl_vendas.py
Essa configuração é apropriada para validar a instalação, não para expor o cluster à internet. A interface web, a porta do master e os serviços auxiliares devem ficar atrás de VPN, bastion host ou regras de firewall. Pacotes e arquivos de configuração podem ser distribuídos com Ansible, imagens versionadas ou um pipeline de infraestrutura como código.
Spark sobre Kubernetes
Kubernetes faz sentido quando a organização já opera clusters, registros de imagens, observabilidade e políticas de acesso. Cada aplicação pode criar pods de driver e executor, com requests e limits explícitos. Um exemplo seria solicitar 4 cores e 16 GiB por executor, reservar 4 GiB de overhead e usar nós de 16 vCPUs e 64 GB. O scheduler precisa ter espaço real para encaixar os pods, incluindo daemons do sistema.
Imagens devem fixar versões de Java, Spark, Python e dependências. Isso evita que dois executores processem o mesmo job com bibliotecas diferentes. Secrets não devem ser inseridos na imagem nem escritos em comandos versionados. Use o mecanismo de secrets do orquestrador, identidades de workload ou credenciais temporárias para acessar armazenamento.
Kubernetes não elimina o planejamento de disco. Se emptyDir utiliza o volume raiz e um executor derrama 300 GB, o nó pode sofrer pressão de armazenamento e expulsar pods. Volumes locais dedicados ou nós com discos temporários dimensionados reduzem esse risco. Para analytics de baixa latência que precisa servir consultas, o desenho muda; veja a arquitetura de ClickHouse para analytics em tempo real antes de usar Spark como banco de consulta interativa.
Segurança, observabilidade e solução de gargalos
Métricas que explicam a lentidão
A primeira ferramenta de diagnóstico é o Spark UI. Compare duração das tarefas, volume de entrada, shuffle read, shuffle write, spill em memória e disco, tempo de coleta de lixo e distribuição por executor. Se 199 tarefas terminam em dois minutos e uma demora 25 minutos, o problema provável é skew, não falta uniforme de CPU. Dividir chaves muito concentradas, aplicar salting ou permitir que o Adaptive Query Execution trate partições podem melhorar o estágio.
CPU baixa com leitura lenta costuma apontar para storage, rede ou arquivos pequenos. CPU próxima de 100% com pouco spill pode indicar que mais cores ajudam, desde que a origem de dados acompanhe. Muitos erros de OutOfMemoryError exigem identificar se a pressão ocorre no driver, no heap do executor ou fora dele. Para um processo Python encerrado pelo sistema, aumentar o overhead pode ser mais útil que aumentar o heap Java.
Além do Spark UI, colete métricas do sistema com Prometheus, Grafana ou a solução do provedor. Monitore uso e steal time de CPU, memória disponível, swap, fila de disco, IOPS, throughput, erros de interface e espaço livre. Centralize logs para preservar evidências quando um Cloud Server for substituído. Um alerta de disco em 80% dá tempo de interromper uma carga antes que o nó fique indisponível.
Proteção da rede e dos dados
Os workers não precisam aceitar conexões da internet pública. Coloque-os em sub-rede privada, libere apenas as portas necessárias entre componentes e use um ponto controlado para administração. SSH deve usar chaves, autenticação restrita, usuários individuais e, de preferência, acesso por VPN ou bastion. Não coloque chaves de storage em scripts, notebooks, imagens ou arquivos enviados ao repositório.
Criptografia em trânsito depende da arquitetura. Conexões com armazenamento de objetos devem usar TLS, e tráfego interno sensível pode exigir recursos de autenticação e criptografia do Spark ou uma rede protegida. Checkpoints, event logs e resultados também precisam de política de retenção e controle de acesso.
Teste falhas de forma intencional. Encerre um worker durante um job de homologação, confirme a repetição das tarefas e meça o impacto. Depois simule indisponibilidade do driver, perda do volume temporário e recusa do storage. Snapshots de servidores não substituem backup dos dados nem uma estratégia reproduzível de implantação. O objetivo é recriar os nós a partir de código e preservar apenas aquilo que realmente precisa sobreviver.
Recomendações por perfil
Dev solo e laboratório
Para estudos, provas de conceito e desenvolvimento de pipelines, três Cloud Servers com 4 vCPUs, 16 GB de RAM e 100 GB de SSD cada oferecem um ambiente distribuído sem custo operacional de um cluster grande. Use um nó como master e driver e dois como workers. Limite cada executor a 3 ou 4 cores e cerca de 10 GB de heap, deixando folga para Linux e overhead. Trabalhe com amostras representativas, como 20 GB a 50 GB, em vez de copiar todo o data lake.
Automatize a instalação desde o início. Um playbook simples deve fixar Java, Spark, Python e diretórios de trabalho. Grave datasets em armazenamento de objetos e aceite que o disco local seja descartável. Esse perfil não precisa de alta disponibilidade, mas precisa ser reproduzível. Se o ambiente ficar desligado por vários dias, recriar as instâncias pode ser mais previsível do que conservar configurações manuais.
Equipe de dados
Uma equipe com pipelines diários, notebooks e múltiplos usuários pode começar com um nó de controle de 8 vCPUs e 32 GB, mais três workers com 8 vCPUs, 32 GB e 200 GB a 300 GB de SSD. Separe filas ou limites por aplicação para impedir que uma consulta experimental ocupe todos os executores. Mantenha event logs, métricas, histórico de jobs e alertas de disco.
Nesse cenário, o teste de carga deve combinar concorrência real. Execute ao mesmo tempo o ETL principal, uma consulta ad hoc e uma compactação de arquivos. Se o cluster trabalha bem isoladamente, mas degrada sob três jobs, ajuste alocação dinâmica, limites e horários antes de ampliar os nós. Registre bytes processados, custo por execução e duração do caminho crítico. Esses números orientam a escolha entre manter capacidade fixa ou criar workers temporários.
Produção crítica
Para cargas que alimentam faturamento, prevenção a fraude ou relatórios com horário rígido, comece com componentes de controle separados e pelo menos quatro workers. Um perfil inicial pode usar 16 vCPUs, 64 GB de RAM e 500 GB de SSD rápido por worker, mas só deve ser aprovado após benchmark. Distribua o cluster por domínios de falha quando o provedor e a arquitetura permitirem, observando que tráfego entre zonas pode acrescentar latência e custo.
Defina objetivo de recuperação, retenção de checkpoints, política de atualização e procedimento para voltar à versão anterior. Teste a substituição de um worker e a recuperação do driver. Dados persistentes devem ficar em uma camada replicada e independente do ciclo de vida das instâncias. Para escolher um provedor, confirme documentação de CPU, limites de rede, tipo de disco, regiões, quotas e cobrança de tráfego. Preço, disponibilidade de NVMe, snapshots e largura de banda variam por plano e localidade, portanto exigem verificação humana na página oficial antes da contratação.
Continue lendo
Perguntas frequentes
Quanta RAM o Apache Spark precisa em um Cloud Server?
Um laboratório distribuído pode começar com 16 GB de RAM por nó, enquanto workers de produção costumam partir de 32 GB ou 64 GB. A memória não deve ser entregue integralmente ao heap dos executores. Reserve de 10% a 20% para Linux, serviços auxiliares e page cache, além do memory overhead de cada executor. Jobs com Python, joins extensos, cache e bibliotecas nativas podem consumir bastante memória fora do heap. O dimensionamento final deve usar métricas do Spark UI, especialmente spill, coleta de lixo e encerramentos de executores.
Quantos cores devem ser atribuídos a cada executor do Spark?
Quatro ou cinco cores por executor formam um ponto inicial prático para muitos jobs. Executores muito grandes concentram memória, ampliam pausas de coleta de lixo e aumentam o impacto de uma falha. Executores pequenos demais criam processos adicionais e consomem mais overhead. Em um worker com 16 vCPUs, uma configuração inicial pode usar três executores de 5 cores, reservando uma vCPU para o sistema. A memória precisa ser calculada junto com os cores, pois três executores com heap e overhead excessivos podem ultrapassar a RAM física do servidor.
SSD ou NVMe faz mais diferença para Apache Spark?
NVMe pode reduzir o tempo de operações com muito shuffle, spill e acesso temporário, mas não acelera todos os pipelines. Se o job fica limitado pela leitura de armazenamento de objetos, por CPU ou por uma partição desbalanceada, o disco mais rápido terá efeito pequeno. SSD já atende muitos clusters moderados. Compare IOPS, throughput sustentado e latência com o workload real. Também confirme se o disco é local ou remoto e se existe limite por instância. O espaço disponível precisa suportar picos temporários maiores que o dataset de entrada.
É melhor executar Spark Standalone ou Kubernetes?
Spark Standalone costuma ser mais simples para um cluster dedicado, pequeno ou médio. Ele reduz a quantidade de componentes e facilita o primeiro diagnóstico. Kubernetes se encaixa melhor quando a empresa já domina imagens, redes, volumes, observabilidade, secrets e políticas de agendamento. O orquestrador melhora padronização e isolamento, mas não elimina a necessidade de dimensionar executores, disco e rede. Adotar Kubernetes apenas para executar um único cluster Spark pode aumentar a complexidade operacional. A decisão deve considerar as competências da equipe e a infraestrutura já mantida.
O armazenamento de objetos substitui o disco local dos workers?
Não. O armazenamento de objetos funciona bem como camada persistente para entradas, saídas, checkpoints e event logs, mas o Spark ainda precisa de espaço local para shuffle, spill e arquivos temporários. Ler e gravar cada bloco temporário diretamente em objetos pode adicionar latência e chamadas remotas. O desenho mais comum combina objetos para durabilidade com SSD ou NVMe local para trabalho descartável. Se um worker for removido, os dados persistentes continuam disponíveis, enquanto tarefas que dependiam do shuffle local podem ser refeitas pelo mecanismo de recuperação do Spark.
Como saber se o cluster Spark precisa de mais servidores?
Observe primeiro se os recursos atuais estão realmente saturados. CPU alta em todos os workers, tarefas equilibradas e storage com capacidade livre podem justificar mais nós. CPU baixa, muito tempo de leitura e throughput limitado apontam para rede ou armazenamento. Uma única tarefa lenta entre centenas indica skew de dados. Falhas por falta de memória podem exigir ajuste de partições, heap ou overhead, não necessariamente novos servidores. Compare Spark UI, métricas do sistema, duração dos estágios e concorrência. Escale somente depois de identificar qual recurso limita o caminho crítico.
Fontes consultadas
- Apache Spark Documentation: Cluster Mode Overview · coletado em 12/11/2026
- Apache Spark Documentation: Hardware Provisioning · coletado em 12/11/2026
- Apache Spark Documentation: Configuration · coletado em 12/11/2026
- Apache Spark Documentation: Running on Kubernetes · coletado em 12/11/2026