Quais os cuidados e como utilizar o Spark juntamente ao Kubernetes?

Published in

A3data

17 min readMar 2, 2023

1. Introdução

O Apache Spark é um dos mais populares frameworks de processamento distribuído de dados em larga escala, que foi criado em 2009 no laboratório de Inteligência Artificial da Universidade da Califórnia em Berkeley. Ele permite o processamento de grandes volumes de dados em um cluster, utilizando técnicas de computação em memória e processamento paralelo para melhorar a eficiência e escalabilidade.

O Spark é usado em várias aplicações, incluindo análise de dados, aprendizado de máquina, processamento de linguagem natural, entre outras. Ele oferece várias APIs para trabalhar com diferentes tipos de dados, incluindo RDDs (Resilient Distributed Datasets), DataFrames e Datasets, além de suporte a diversas linguagens, como Python, Scala, Java e R.

O Kubernetes, por sua vez, é uma plataforma de orquestração de contêineres que permite o gerenciamento de aplicações em larga escala, com alta disponibilidade e escalabilidade. Ele ajuda a garantir que os contêineres estejam sempre funcionando, fazendo a escalabilidade horizontal e vertical, e oferecendo recursos de monitoramento, gerenciamento de recursos e segurança.

Quando combinamos ambas as tecnologias podemos obter muitos benefícios para empresas, pois poderemos processar grandes volumes de dados de forma escalonável e customizável. Isso é possível pelo gerenciamento de recursos por parte do Kubernetes, enquanto o Spark pode ser usado para processar os dados. Sendo assim, unindo ambas as ferramentas conseguimos simplificar o gerenciamento do ambiente, garantir alta disponibilidade e escalabilidade, além de permitir uma melhor utilização dos recursos disponíveis.

Portanto, a fim de viabilizar a criação de aplicações Spark gerenciadas pelo Kubernetes, é imprescindível, que sejam observados determinados cuidados para que os benefícios elencados previamente possam ser alcançados. Dessa maneira, o primeiro cuidado a ser considerado no processo de construção de uma aplicação Spark no Kubernetes consiste em responder a seguinte questão:

Qual é a arquitetura do Apache Spark e como ela permite o processamento de dados em larga escala?

2. Como funciona o Spark

O Apache Spark é um framework para processamento distribuído de dados onde grandes volumes de dados são processados em um tempo relativamente curto. Este tempo so é possível graças à arquitetura interna do Spark, que utiliza o modelo mestre-escravo para o paralelismo. No entanto, o Spark diferencia-se de outros frameworks ao atuar principalmente em memória, o que torna o processamento de grandes volumes de dados mais eficiente.

A arquitetura mestre-escravo é um modelo de arquitetura de software onde um servidor central (mestre) é responsável por gerenciar e coordenar as atividades de um ou mais clientes (escravos). O mestre é responsável por receber solicitações dos clientes, distribuir as tarefas aos escravos e consolidar os resultados. Os escravos executam as tarefas atribuídas pelo mestre e enviam os resultados de volta.

Tudo que falamos até agora está relacionado à forma como o Spark distribui o hardware. Ao analisarmos a estrutura lógica, encontramos os RDDs (Resilient Distributed Datasets), que gerenciam a distribuição dos dados entre os nós do cluster. Esse conceito permite ao Spark executar operações complexas em grandes conjuntos de dados de forma eficiente, possibilitando o processamento em memória. Depois, o Spark adicionou o conceito de DataFrames/Datasets, que simplifica o uso dos RDDs e permite sua utilização em várias linguagens de programação.

Compreender a arquitetura interna do Spark é crucial para explorar todo o potencial deste framework de processamento distribuído. O motor de processamento do Spark é constituído por vários componentes, que trabalham juntos para permitir o processamento distribuído de grandes conjuntos de dados. Além disso, entender a arquitetura interna do Spark é uma etapa importante para otimizar o desempenho e a eficiência das aplicações desenvolvidas com esse framework.

2.1 A arquitetura

Como apresentado a arquitetura do Spark é baseada em um sistema mestre-escravo, onde o Driver atua como representante do mestre e os Executors e as tasks como representantes dos escravos. O Cluster Manager é responsável por gerenciar os recursos do cluster e escalonar as aplicações Spark. Todos esses componentes trabalham juntos para garantir que o processamento distribuído seja realizado de forma eficiente e escalável.

O Driver é o componente responsável por orquestrar a execução da aplicação Spark, criando a SparkContext e distribuindo o código para os nós do cluster, além de definir o DAG da aplicação e enviar as tarefas para os Executors. Além disso, no driver, temos a presença da SparkSession que é responsável por criar o contexto de execução do Spark e gerenciar a conexão com o cluster. Por meio dela é possível ler e escrever dados de diferentes formatos, criar dataframes, executar operações em SQL e executar tarefas no cluster. Dessa forma, sendo essa a forma do usuário desenvolver suas aplicações.

Os Executors são responsáveis por executar as tarefas definidas pelo Driver em cada nó do cluster, gerenciando a execução de cada uma delas e alocando recursos como CPU e memória para o processamento. Já as tasks são as unidades básicas de processamento no Spark, distribuídas pelo Driver aos Executors para que possam ser executadas em paralelo em diferentes nós do cluster.

2.1.1 Número de taks

Em geral, é recomendado que haja um número de tarefas por executor que seja múltiplo do número de núcleos disponíveis no nó de trabalho, para que cada núcleo possa ser utilizado de forma eficiente. A configuração do número de tarefas por executor pode ser feita através da propriedade “spark.executor.instances” no arquivo de configuração do Spark ou através do método “setExecutorInstances” na classe “SparkConf” na aplicação Spark. É importante ressaltar que o número de tarefas por executor pode variar dependendo do tipo de operação que está sendo executada e das características dos dados, sendo recomendado realizar testes de desempenho com diferentes configurações

2.1.2 Alocação de memória

Quando avaliamos a quantidade recomendada de memória necessária, é preciso avaliar a volumetria dos dados em termos de bytes por partição de dados. Essa é a principal consideração na construção de uma aplicação Spark e o principal ponto de ajuste de desempenho (tuning) do Spark. Isso se deve às diferentes categorias de memória do Spark e à forma como ele as aloca para cada uma delas.

O Spark utiliza a memória off-heap para armazenar dados de maneira mais eficiente e para reduzir a coleta de lixo realizada pelo Garbage Collector do Java. No entanto, é necessário considerar a memória on-Heap que é a memoria dos executores, que é a memória padrão do Java utilizada pelo Spark para armazenar objetos Java. Dessa forma, devemos concentrar nossos cuidados com a memória padrão, on-heap, que é dividida em quatro categorias , sendo elas:

Execution Memory: é a memória usada para armazenar dados intermediários durante a execução das tarefas no Spark. Essa memória é alocada dinamicamente pelo Spark e é usada principalmente para armazenar dados de tamanho médio, como partições de dados.
Storage Memory: é a memória usada para armazenar os dados em cache no Spark. Essa memória é alocada dinamicamente e é usada para armazenar dados de tamanho maior que o Execution Memory, como o resultado de operações de shuffle e de agregação.
Reserved Memory: é usada para armazenar dados internos e metadados do sistema no início da execução, sem ser usada para processamento de dados. Essa memória contém informações como configurações, status e estatísticas de desempenho, além de dados do plano de execução do aplicativo.
User Memory: é uma memória adicional que pode ser alocada pelo usuário do Spark para armazenar dados específicos da aplicação. Essa memória é alocada usando a API MemoryManager do Spark.

É importante notar que esses tipos de memórias podem ser configurados de forma diferente no Spark, dependendo das necessidades da aplicação. Além disso, devemos considerar tomar o cuidado que parte da memoria utilizada pelo spark não é utilizado no processamento.

E para que possamos ter acesso aos recursos sejam eles GPU, CPU, memoria precisamos garantir um “meio de campo” para gerencia-los. Neste ponto entra o Cluster Manager.

2.2 Cluster Manager

O Cluster Manager é um componente fundamental da arquitetura do Spark, responsável por gerenciar os recursos do cluster e escalonar as aplicações Spark para serem executadas nos nós disponíveis. Ele identifica os nós disponíveis no cluster e aloca recursos para cada aplicação Spark, podendo ser integrado a diferentes sistemas de gerenciamento de cluster como o Apache Mesos, Hadoop YARN e Kubernetes.

Standalone: é um cluster manager simples, que é distribuído com o Spark. É fácil de configurar e usar, mas não é tão escalável quanto os outros cluster managers.
Apache Mesos: é um cluster manager distribuído que gerencia recursos em um cluster e suporta a execução de várias estruturas de processamento, incluindo o Spark. Ele é altamente escalável e pode lidar com grandes clusters de máquinas.
Kubernetes: é uma plataforma de orquestração de contêineres que fornece recursos para gerenciar e orquestrar contêineres em um cluster. Ele pode ser usado como um cluster manager para o Spark e tem recursos avançados de escalabilidade e gerenciamento de recursos.
YARN: é um framework de gerenciamento de recursos para clusters do Hadoop. Ele é usado para gerenciar recursos de hardware e programar a execução de aplicativos no cluster. O Spark pode ser executado no YARN como um cliente de aplicativo ou em modo cluster.

A escolha do cluster manager depende das necessidades de cada aplicação e do ambiente de execução. Quando uma aplicação Spark é submetida ao cluster manager, o mesmo alocará recursos necessários para que a aplicação possa ser executada, como CPU, memória e armazenamento. O cluster manager também monitora o estado de cada nó do cluster e redireciona o trabalho da aplicação para outros nós, caso ocorra uma falha em algum nó do cluster. Além disso, o cluster manager é responsável por garantir a segurança do cluster e a execução das aplicações em ambientes isolados. Dessa forma, o cluster manager garante a disponibilidade e a escalabilidade das aplicações Spark no cluster e nesse ponto, o kubernetes por permitir alta customização de recursos à aplicações de forma isolada se torna um excelente candidato a ser nosso cluster manager.

Como o kubernetes permite essa customização e como instanciamos o spark como um container?

3. Rodando o spark no Kubernetes

Kubernetes é uma plataforma de orquestração de contêineres de código aberto que permite automatizar a implantação, escalonamento e gerenciamento de aplicativos em contêineres. Seu objetivo é simplificar o processo de implantação de aplicativos em ambientes de produção, oferecendo ferramentas de gerenciamento e escalabilidade avançadas.

A arquitetura do Kubernetes é composta por diversos componentes que trabalham juntos para fornecer uma plataforma completa de gerenciamento de contêineres. Entre os principais componentes estão:

API Server: é o componente central do Kubernetes e funciona como ponto de entrada para as interações entre os usuários e o cluster Kubernetes. É responsável por validar e processar as solicitações recebidas e, em seguida, coordenar com os outros componentes para executar a ação solicitada.
Scheduler: é o componente responsável por distribuir e agendar as cargas de trabalho do Kubernetes em diferentes nós do cluster, levando em consideração fatores como recursos disponíveis e políticas de alocação.
Etcd: é um banco de dados distribuído que armazena as informações do estado do cluster Kubernetes. Ele fornece um registro centralizado e confiável das configurações e estados dos recursos do cluster, permitindo que os componentes do Kubernetes coordenem e trabalhem em conjunto.
Controllers: são componentes responsáveis por monitorar e controlar o estado dos recursos no cluster. Eles garantem que os recursos do Kubernetes estejam em conformidade com as políticas de configuração e fornecem feedback para o Scheduler para garantir a escalabilidade ideal.
Kubelet: é o componente responsável por gerenciar os nós do cluster Kubernetes. Ele garante que os contêineres estejam sendo executados de acordo com as especificações desejadas e se comunica com o Scheduler e o API Server para coordenar o gerenciamento de recursos do cluster.
Kube proxy: é um componente do Kubernetes que gerencia o tráfego de rede dentro do cluster. Ele é responsável por garantir que os serviços estejam acessíveis aos usuários e redirecionar o tráfego para os pods corretos. O Kubeproxy também pode ser configurado para fornecer serviços de balanceamento de carga, proxy reverso e encaminhamento de porta.

O Kubernetes usa o conceito de objetos, como pods, serviços e deployments, para gerenciar os recursos do cluster. Cada objeto tem um estado desejado definido pelo usuário e o Kubernetes trabalha para garantir que o estado atual do objeto esteja sempre em conformidade com o estado desejado. Isso é feito por meio de ciclos de reconciliação, onde o estado, isso mesmo o kubernetes atua com estados, atual do objeto é verificado em relação ao estado desejado e são tomadas as ações necessárias para garantir que o estado atual seja atualizado para corresponder ao estado desejado.

Para a utilização do Spark no Kubernetes, precisamos criar aplicações gerir conexões e todos os setups de infraestrutura. No entanto foi desenvolvida uma ferramenta que utiliza o recurso CRD do Kubernetes para adicionar recursos personalizados ao seu cluster de forma simples e eficiente. Com essa solução, é possível estender as funcionalidades do Kubernetes e criar definições personalizadas de recursos, tornando mais fácil e prático o gerenciamento do ambiente de dados.

3.1 CRDs

Custom Resource Definition, ou CRD, é um recurso disponível no Kubernetes que permite estender o seu modelo de recursos padrão e criar definições personalizadas de recursos. Em outras palavras, é possível criar novos tipos de recursos no Kubernetes e descrever suas aplicações ou serviços, incluindo o esquema e comportamento desejado para o recurso personalizado, bem como as operações que podem ser executadas nele.

Os CRDs são criados utilizando a API do Kubernetes, o que permite que sejam gerenciados de forma padronizada por meio de ferramentas como o kubectl. O uso de CRDs é particularmente útil para a implementação de operações personalizadas em um cluster Kubernetes, como por exemplo, armazenar configurações específicas de aplicações ou definir políticas de segurança. Esse recurso é especialmente útil para desenvolvedores e engenheiros de plataforma que desejam estender o Kubernetes para atender às necessidades específicas de sua organização.

3.2 SparkOperator

A CRD do Spark operator permite que os usuários provisionem clusters Spark em Kubernetes com as configurações desejadas, definindo o número de nós de trabalho e personalizando as propriedades do Spark para atender às suas necessidades de processamento de dados. Além disso, o Spark Operator simplifica a gestão e monitorização do cluster Spark, permitindo que os usuários monitorem o status dos trabalhos em execução e vejam as métricas do cluster em tempo real. Para mais informações sobre o SparkOperator, clique aqui e seja redirecionado para a documentação oficial. Agora, vamos as instruções. Por padrão definimos o nome da nossa namespace como processing, lá deverá ser executadas todas as aplicações spark.

1 . Crie o namespace onde os seus recursos serão instanciados:

kubectl create namespace processing

2 . Adicione o repositório do helm que contém a imagem do SparkOperator

helm repo add spark-operator https://googlecloudplatform.github.io/spark-on-k8s-operator
helm repo update
helm install --set image.tag=v1beta2-1.3.2-3.1.1 spark spark-operator/spark-operator --namespace processing --create-namespace
helm ls -n processing

3 . Agora iremos criar uma conta de serviço e uma role, no namespace.

kubectl create serviceaccount spark -n processing
kubectl create clusterrolebinding spark-role --clusterrole=edit --serviceaccount=processing:spark --namespace=processing

Com o intuito de criar aplicações no Kubernetes, é necessário construir arquivos YAML que são monitorados por meio de manifestos pelo próprio Kubernetes. Esses arquivos possuem uma estrutura de codificação que permite a especificação das configurações de execução. Como exemplo, podemos considerar a execução de um código em Python localmente, que pode ser realizada seguindo o exemplo abaixo.

apiVersion: "sparkoperator.k8s.io/v1beta2"
kind: SparkApplication
metadata:
  name: spark-job
spec:
  type: Python
  pythonVersion: "3"
  mode: cluster
  image: spark-py:latest
  mainApplicationFile: local:///app/main.py
  sparkVersion: "3.1.1"
  restartPolicy:
    type: Never
  executor:
    cores: 2
    instances: 2
    memory: "2g"
  driver:
    cores: 1
    memory: "1g"
  request:
    memory: "3g"
    cpu: "1"
    limit:
      memory: "4g"
      cpu: "2"

Para este exemplo estamos usando a versão 3 do Python e definimos a imagem que contém as bibliotecas e dependências necessárias para a execução do job Spark, por padrão acessa ao docker hub. Nas configurações do driver especificamos que queremos 1 núcleo e 1 GB de memória para o driver, embora foi solicitados 3 GB de memória e 2 CPU. Ja na configuração executor foi especificado 2 instâncias do executor, cada uma com 2 núcleos e 2 GB de memória.

4 . E finalmente para executar a nossa aplicação Spark, aplicamos o devido template e indicamos o namespace.

kubectl apply -f caminho_do_arquivo/arquivo.yml -n processing

Apesar de funcional, essa aplicação não segue as boas práticas de construção de software. Para evoluí-la, uma opção é construir a imagem do Spark adicionando os códigos a serem executados no container. Desse modo, apresentaremos como construir a imagem do Spark de forma adequada.

3.3 Construindo a sua primeira Imagem com Spark

Por ser open source a apache spark disponibiliza o seu codigo e podemos construir imagens baseada nelas. Em sua própria documentação temos a exemplificação, por meio de comandos bash de como construí-la. O primeiro passo é acessar a sua página de download e selecionar o tipo do package como SOURCE CODE.

Em seguida, acessamos a pasta descomprimida e podemos construir a nossa imagem de acordo com a oficial:

REGISTRY=<SEU REGISTRY (DOCKER HUB, ECR OU OUTROS)>
REPOSITORY=spark
IMAGE_TAG=v3.2.3-hadoop3

bash ./bin/docker-image-tool.sh -r $REGISTRY -t $IMAGE_TAG -p ./kubernetes/dockerfiles/spark/bindings/python/Dockerfile build
bash ./bin/docker-image-tool.sh -r $REGISTRY -t $IMAGE_TAG push

Nesse ponto, teremos acesso a uma imagem isolada onde podemos modifica-la para atender a nossa demanda e isso é realizado por meio de um docker file:

FROM <SUA IMAGEM CRIADAv3.2.3-hadoop3>

# using root
USER root:root

# Cria um diretorio de applications
RUN mkdir -p /app

# Copia seus codigos locais para dentro da imagem
COPY app/* /app/

# Copia arquivos jars
COPY ./jars/sparkoperator/ /opt/spark/jars

#set directory principal
WORKDIR /app

# Instala bibliotecas pythons usadas no python3
RUN pip3 install -r requirements.txt

# Set o path de execução do python
ENV PYSPARK_PYTHON=/usr/bin/python3

#user
USER root

Dessa maneira podemos manipular uma imagem spark, mas e para monitorar e saber como esta o seu funcionamento?

3.4 Monitoramento de suas aplicações

Monitoramento no Spark refere-se ao processo de observar o desempenho e o comportamento do cluster do Spark durante a execução dos jobs. Para garantir a eficácia do cluster, é fundamental que o este seja realizado de forma constante, permitindo que os administradores possam identificar possíveis gargalos, otimizar a utilização dos recursos e solucionar problemas de maneira rápida e eficiente.

No Kubernetes, a forma de monitorar a aplicação Spark consiste em acessar sua SparkApplication e analisar a estrutura do job. Em seguida, é possível acessar os logs gerados pelo driver.

kubectl get sparkapplication <sua spark aplication>  -n processing -oyaml
kubectl logs -f <driver da sua spark aplication> -n processing

Entretanto, a leitura de logs pode ser uma tarefa tediosa e muitos fatores que requerem observação podem passar despercebidos. Como solução, foi desenvolvida uma ferramenta capaz de exibir em um dashboard todos os jobs e tarefas realizados pelas aplicações, chamada de Spark History.

3.4.1 Spark History

Uma das ferramentas utilizadas para o monitoramento no Spark é o Spark History, que permite o acompanhamento da execução de jobs e a análise do desempenho do cluster. Ele mantém um registro das execuções de aplicativos e fornece uma visão detalhada do desempenho do aplicativo, incluindo a lista completa de tarefas executadas e as métricas de desempenho correspondentes.

O sua arquitetura é composta pelo Spark History Server e o Application History Provider. O Spark History Server exibe informações como a lista de tarefas executadas, métricas de desempenho e visualizações dos stages e plano de execução do Spark. A ferramenta possui recursos avançados como a busca em registros e navegação por linha do tempo. O Application History Provider coleta informações, como logs do driver e plano de execução, armazenando-as em um local persistente para posterior análise. O Spark History Server acessa esses dados para exibir as informações em sua interface web. O Spark History permite monitorar e analisar o desempenho de aplicações Spark em clusters, fornecendo uma interface intuitiva e amigável para visualização dos dados coletados.

Uma maneira de aprimorar a monitorização da aplicação é fornecendo informações sobre a eficiência e as principais métricas de ajuste. Nesse sentido, a Spot e Data Mechanics desenvolveram a ferramenta Delight, que permite medir o desempenho do aplicativo e apresentar essas informações de forma detalhada em um painel de controle.

3.4.2 Delight

A Delight é uma plataforma em nuvem que oferece suporte para clusters Apache Spark e sua ferramenta de monitoramento do Spark apresenta um painel de controle centralizado para visualizar as métricas de desempenho das aplicações Spark em execução. O painel oferece um resumo do desempenho do cluster, lista de jobs e tarefas em execução, métricas de utilização de recursos e tempos de execução.

Além disso, a ferramenta oferece recursos avançados de análise, como alertas configuráveis, gráficos de desempenho histórico e a capacidade de comparar o desempenho de execuções diferentes. Com essa ferramenta, é possível detectar rapidamente possíveis problemas e gargalos de desempenho, permitindo aos usuários gerenciar seus recursos de forma mais eficiente e otimizar o desempenho de suas aplicações.

Por mei da ferramenta os usuários podem identificar rapidamente possíveis problemas de desempenho e ajustar suas aplicações para melhorar sua eficiência. Com um painel de controle centralizado e recursos avançados de análise, a ferramenta Delight Data Mechanics oferece uma solução abrangente para monitoramento de desempenho de aplicações Spark em clusters e permite o acesso diretamente com a spark UI.

Para utilizar a ferramenta, é necessário compreender como ela se conecta ao cluster Kubernetes. A conexão é estabelecida por meio de uma API, que requer um token de autenticação na chamada. Além disso, é necessário adicionar o arquivo jar ao cluster para permitir a comunicação. Essa comunicação é realizada por meio de listeners que coletam os logs da aplicação e, quando finalizada, enviam-nos para o webserver da aplicação, onde é fornecido o dashboard e o acesso à Spark UI.

É possível configurar a conexão com a plataforma Delight no manifesto de criação da Spark Application. No exemplo abaixo temos um manifesto avançado onde é incluindo configurações como o SparkConf, download do jar na criação do job, configurações de conexão por meio do protocolo S3 e segredos de acesso à AWS e ao banco de dados.

apiVersion: "sparkoperator.k8s.io/v1beta2"
kind: SparkApplication
metadata:
  name: <NOME APPLICATION>
  namespace: processing
spec:
  deps:
    jars:
      - "https://oss.sonatype.org/content/repositories/snapshots/co/datamechanics/delight_2.12/latest-SNAPSHOT/delight_2.12-latest-SNAPSHOT.jar"
  volumes:
    - name: ivy
      emptyDir: {}
  sparkConf:
    spark.driver.extraJavaOptions: "-Divy.cache.dir=/tmp -Divy.home=/tmp, -Dcom.amazonaws.services.s3.enableV4"
    spark.executor.extraJavaOptions: "-Dcom.amazonaws.services.s3.enableV4"
    spark.kubernetes.allocation.batch.size: "10"
    spark.delight.accessToken.secret: "SEU TOKEN"
    spark.extraListeners: "co.datamechanics.delight.DelightListener"
  hadoopConf:
    fs.s3a.impl: org.apache.hadoop.fs.s3a.S3AFileSystem
    fs.s3a.path.style.access: "True"
  type: Python
  pythonVersion: "3"
  mode: cluster
  image: <SUA IMAGEM>
  imagePullPolicy: Always
  mainApplicationFile: local:///app/SEU-python-FILE.py
  sparkVersion: "3.2.2"
  timeToLiveSeconds: 600
  restartPolicy:
    type: Never
  driver:
    envSecretKeyRefs:
      AWS_ACCESS_KEY_ID:
        name: aws-credentials
        key: aws_access_key_id
      AWS_SECRET_ACCESS_KEY:
        name: aws-credentials
        key: aws_secret_access_key
      DB_URL:
        name: db-credentials
        key: url
      DB_USER:
        name: db-credentials
        key: user
      DB_PASSWORD:
        name: db-credentials
        key: password
    cores: 1
    coreRequest: "500m"
    coreLimit: "1200m"
    memory: "4g"
    labels:
      version: 3.0.0
    serviceAccount: spark
    volumeMounts:
      - name: ivy
        mountPath: /tmp
  executor:
    envSecretKeyRefs:
      AWS_ACCESS_KEY_ID:
        name: aws-credentials
        key: aws_access_key_id
      AWS_SECRET_ACCESS_KEY:
        name: aws-credentials
        key: aws_secret_access_key
    cores: 2
    coreRequest: "500m"
    coreLimit: "1200m"
    instances: 2
    memory: "2g"
    labels:
      version: 3.0.0
    volumeMounts:
      - name: ivy
        mountPath: /tmp

4. Conclusão

Portanto, a combinação do Apache Spark e Kubernetes pode oferecer uma solução robusta, escalável e flexível para processamento de grandes volumes de dados em ambientes distribuídos. Isso pode ajudar as empresas a obter insights mais rápidos e precisos a partir de seus dados, tornando-se mais competitivas e eficientes em seus processos de negócios. Além disso, com o delight podemos monitorar e aprimorar o uso dos recursos no processamento.