Entendendo a alocação de recursos para tarefas spark em mesos

Estou trabalhando em um projeto no Spark e recentemente mudei do Spark Standalone para o Mesos para gerenciamento de cluster. Agora me vejo confuso sobre como alocar recursos ao enviar um trabalho no novo sistema.

No modo autônomo, eu estava usando algo parecido com isto (seguindo algumas recomendações deesta postagem no blog Cloudera:

/opt/spark/bin/spark-submit --executor-memory 16G --executor-cores 8 
    --total-executor-cores 240 myscript.py

Isso ocorre em um cluster em que cada máquina possui 16 núcleos e ~ 32 GB de RAM.

O que foi legal nisso foi que eu tinha um bom controle sobre o número de executores em execução e os recursos alocados a cada um. No exemplo acima, eu sabia que estava recebendo 240/8 = 30 executores, cada um com 16 GB de memória e 8 núcleos. Dada a memória em cada máquina no cluster, isso equivaleria a não mais de dois executores em execução em cada máquina. Se eu quisesse mais executores, eu poderia fazer algo como

/opt/spark/bin/spark-submit --executor-memory 10G --executor-cores 5 
    --total-executor-cores 240 myscript.py

Agora, isso me daria 240/5 = 47 executores, cada um com 5 núcleos e 10 GB de memória, e permitiria até 3 executores por máquina.

Mas agora que estou no mesos, estou ficando um pouco confuso. Primeiro, estou executando no modo de granulação grossa para garantir que eu possa corrigir e controlar minha alocação de recursos (isso está ao serviço de um modelo bastante complexo onde queremos pré-alocar recursos).

Agora eu posso especificar--total-executor-cores e--executor-memory, mas a documentação me diz que--exeuctor-cores aplica-se apenas ao Spark independente e ao YARN, o que dificulta a especificação do número total de executores e recursos alocados a cada um. Digamos que eu execute isso:

/opt/spark/bin/spark-submit --total-executor-cores 240 --executor-memory 16G --conf spark.mesos.coarse=true myscript.py

Quando examino esse trabalho na interface da web do Mesos, as coisas começam a ficar confusas. Então, aqui estão as minhas questões:

Terminologia. A interface da Web da Web lista "estruturas", que eu assumo corresponder a "tarefas" na interface do usuário independente. Mas quando clico nos detalhes de um determinado quadro, ele lista "tarefas". Mas essas não podem ser tarefas reais do Spark, certo? Tanto quanto posso dizer, "tarefa" aqui deve realmente significar "executor" no que diz respeito ao Spark. Isso seria consistente com a interface do usuário dizendo que minha estrutura (trabalho) possui: 15 tarefas ativas, 240 CPUs e 264 GB de memória.

264/15 = 17,6, o que parece consistente com a memória de 16 GB por executor que eu especifiquei (mais alguma sobrecarga, eu acho). Estou certo sobre como estou interpretando tudo isso?

Supondo que sim, ao examinar qualquer uma dessas "tarefas" (executores), vejo que cada um tem 16 núcleos atribuídos. Dado que temos 16 núcleos por máquina, isso parece indicar que estou basicamente executando um executor em cada uma das 16 máquinas e que cada executor está obtendo os 16 núcleos completos, mas apenas 16 GB de RAM. (observe que, mesmo que eu largue--executor-memory no caminho, para algo como 4 GB, o mesos ainda executa apenas um executor por nó, com 16 núcleos e 4 GB de RAM). Mas o que eu quero realizar é algo como meus dois primeiros exemplos. Ou seja, desejo executar vários executores por nó, cada um compartilhando a RAM e os núcleos desse nó (ou seja, um número moderado de núcleos pré-executores, 5-8). Considerando que não posso especificar--executor-cores em Mesos, como faço para fazer isso? Ou estou muito fora da base, por algum motivo, querendo fazer isso? O Mesos simplesmente não permitirá vários exeutores por nó?

questionAnswers(2)

yourAnswerToTheQuestion