O que são trabalhadores, executores, núcleos no cluster Spark Standalone?

Li a Visão geral do modo de cluster e ainda não consigo entender os diferentes processos no cluster do Spark Standalone e o paralelismo.

O trabalhador é um processo da JVM ou não? Eu executei o bin\start-slave.she descobri que ele gerou o trabalhador, que na verdade é uma JVM.

Conforme o link acima, um executor é um processo iniciado para um aplicativo em um nó de trabalho que executa tarefas. Um executor também é uma JVM.

Estas são as minhas perguntas:

1. Executores são por aplicativo. Então, qual é o papel de um trabalhador? Ele coordena com o executor e comunica o resultado de volta ao driver? Ou o motorista fala diretamente com o executor? Se sim, qual é o propósito do trabalhador?

2. Como controlar o número de executores de um aplicativo?

3. As tarefas podem ser executadas em paralelo dentro do executor? Se sim, como configurar o número de threads de um executor?

4. Qual é a relação entre um trabalhador, executores e núcleos de executores (--total-executor-cores)?

5. O que significa ter mais trabalhadores por nó?

Atualizada

Vamos dar exemplos para entender melhor.

Exemplo 1: Um cluster autônomo com 5 nós de trabalho (cada nó com 8 núcleos) Quando inicio um aplicativo com configurações padrão.

Exemplo 2 Mesma configuração de cluster do exemplo 1, mas eu executo um aplicativo com as seguintes configurações --executor-cores 10 --total-executor-cores 10.

Exemplo 3 A mesma configuração de cluster do exemplo 1, mas eu executo um aplicativo com as seguintes configurações --executor-cores 10 --total-executor-cores 50.

Exemplo 4 mesma configuração de cluster do exemplo 1, mas eu executo um aplicativo com as seguintes configurações --executor-cores 50 --total-executor-cores 50.

Exemplo 5 mesma configuração de cluster do exemplo 1, mas eu executo um aplicativo com as seguintes configurações --executor-cores 50 --total-executor-cores 10.

Em cada um desses exemplos, quantos executores? Quantos threads por executor? Quantos núcleos? Como é decidido o número de executores por aplicativo? É sempre o mesmo que o número de trabalhadores?

O Spark usa uma arquitetura mestre / escravo. Como você pode ver na figura, ele possui um coordenador central (Driver) que se comunica com muitos trabalhadores distribuídos (executores). O driver e cada um dos executores são executados em seus próprios processos Java.

MOTORISTA

O driver é o processo em que o método principal é executado. Primeiro, ele converte o programa do usuário em tarefas e, em seguida, agenda as tarefas nos executores.

EXECUTORES

Executores são processos de nós trabalhadores encarregados de executar tarefas individuais em uma determinada tarefa do Spark. Eles são iniciados no início de um aplicativo Spark e normalmente são executados durante toda a vida útil de um aplicativo. Depois de executarem a tarefa, eles enviam os resultados ao motorista. Eles também fornecem armazenamento na memória para RDDs que são armazenados em cache pelos programas do usuário por meio do Block Manager.

FLUXO DE EXECUÇÃO DO APLICATIVO

Com isso em mente, quando você envia um aplicativo ao cluster com envio por spark, é o que acontece internamente:

1. Um aplicativo independente inicia e instancia uma SparkContextinstância (e é somente nesse momento que você pode chamar o aplicativo de driver).
2. O programa do driver solicita recursos ao gerenciador de cluster para iniciar os executores.
3. O gerenciador de cluster inicia os executores.
4. O processo do driver é executado no aplicativo do usuário. Dependendo das ações e transformações sobre a tarefa de RDDs, são enviadas aos executores.
5. Executores executam as tarefas e salvam os resultados.
6. Se algum trabalhador travar, suas tarefas serão enviadas para diferentes executores para serem processadas novamente. No livro "Learning Spark: análise de big data extremamente rápida", eles falam sobre Spark e tolerância a falhas:

O Spark lida automaticamente com máquinas lentas ou com falha, reexecutando tarefas lentas ou com falha. Por exemplo, se o nó executando uma partição de uma operação map () travar, o Spark executará novamente em outro nó; e mesmo se o nó não travar, mas for simplesmente muito mais lento que outros nós, o Spark poderá lançar preventivamente uma cópia "especulativa" da tarefa em outro nó e obter o resultado se isso terminar.

7. Com SparkContext.stop () do driver ou se o método principal sair / travar, todos os executores serão encerrados e os recursos do cluster serão liberados pelo gerenciador de cluster.

SUAS PERGUNTAS

1. Quando os executores são iniciados, eles se registram no driver e, a partir de então, se comunicam diretamente. Os trabalhadores são responsáveis ​​por comunicar ao gerente do cluster a disponibilidade de seus recursos.

2. Em um cluster YARN, você pode fazer isso com --num-executors. Em um cluster independente, você obterá um executor por trabalhador, a menos que jogue com spark.executor.cores e um trabalhador tenha núcleos suficientes para armazenar mais de um executor. (Como @JacekLaskowski apontou, --num-executors não está mais em uso no YARN https://github.com/apache/spark/commit/16b6d18613e150c7038c613992d80a7828413e66 )

3. Você pode atribuir o número de núcleos por executor com --executor-cores

4. --total-executor-cores é o número máximo de núcleos de executores por aplicativo

5. Como Sean Owen disse neste tópico : "não há um bom motivo para executar mais de um trabalhador por máquina". Você teria muitas JVM instaladas em uma máquina, por exemplo.

ATUALIZAR

Não pude testar esses cenários, mas de acordo com a documentação:

EXEMPLO 1: O Spark adquirirá avidamente quantos núcleos e executores quantos forem oferecidos pelo planejador. Então, no final, você terá 5 executores com 8 núcleos cada.

EXEMPLO 2 a 5: O Spark não poderá alocar quantos núcleos forem solicitados em um único trabalhador, portanto, nenhum executor será iniciado.

É assim que o Apache Spark trabalha internamente: