Cosa sono i lavoratori, i dirigenti, i nuclei nel cluster Spark Standalone?

Ho letto la panoramica sulla modalità cluster e non riesco ancora a capire i diversi processi nel cluster Spark Standalone e il parallelismo.

Il lavoratore è un processo JVM o no? Ho eseguito il bin\start-slave.she ho scoperto che ha generato il lavoratore, che in realtà è una JVM.

Secondo il link sopra, un esecutore è un processo avviato per un'applicazione su un nodo di lavoro che esegue attività. Un esecutore è anche un JVM.

Queste sono le mie domande:

1. Gli esecutori sono per applicazione. Allora qual è il ruolo di un lavoratore? Si coordina con l'esecutore e comunica il risultato al conducente? O il conducente parla direttamente con l'esecutore? In tal caso, qual è lo scopo del lavoratore allora?

2. Come controllare il numero di esecutori per un'applicazione?

3. È possibile eseguire le attività in parallelo all'interno dell'esecutore? In tal caso, come configurare il numero di thread per un esecutore?

4. Qual è la relazione tra lavoratore, esecutori e core esecutori (--total -ecutor-core)?

5. Cosa significa avere più lavoratori per nodo?

aggiornato

Facciamo esempi per capire meglio.

Esempio 1: un cluster autonomo con 5 nodi di lavoro (ogni nodo con 8 core) Quando avvio un'applicazione con impostazioni predefinite.

Esempio 2 Stessa configurazione del cluster dell'esempio 1, ma eseguo un'applicazione con le seguenti impostazioni --executor-cores 10 --total -ecutor-core 10.

Esempio 3 Stessa configurazione del cluster dell'esempio 1, ma eseguo un'applicazione con le seguenti impostazioni --executor-cores 10 --total -ecutor-cores 50.

Esempio 4 Stessa configurazione del cluster dell'esempio 1, ma eseguo un'applicazione con le seguenti impostazioni --executor-cores 50 --total -ecutor-core 50.

Esempio 5 Stessa configurazione del cluster dell'esempio 1, ma eseguo un'applicazione con le seguenti impostazioni --executor-cores 50 --total -ecutor-core 10.

In ciascuno di questi esempi, quanti esecutori? Quanti thread per esecutore? Quanti core? Come viene deciso il numero di esecutori per domanda? È sempre lo stesso del numero di lavoratori?

Spark utilizza un'architettura master / slave. Come puoi vedere nella figura, ha un coordinatore centrale (Driver) che comunica con molti lavoratori distribuiti (esecutori). Il driver e ciascuno degli esecutori vengono eseguiti nei propri processi Java.

DRIVER

Il driver è il processo in cui viene eseguito il metodo principale. Innanzitutto converte il programma utente in attività e successivamente pianifica le attività sugli esecutori.

ESECUTORI

Gli esecutori sono i processi dei nodi di lavoro incaricati di eseguire singole attività in un determinato lavoro Spark. Vengono avviati all'inizio di un'applicazione Spark e in genere vengono eseguiti per l'intera durata di un'applicazione. Dopo aver eseguito l'attività, inviano i risultati al driver. Forniscono inoltre spazio di archiviazione in memoria per RDD memorizzati nella cache dai programmi utente tramite Block Manager.

FLUSSO DI ESECUZIONE DELL'APPLICAZIONE

Con questo in mente, quando si invia una domanda al cluster con spark-submit, questo è ciò che accade internamente:

1. Un'applicazione autonoma avvia e crea un'istanza di SparkContextun'istanza (ed è solo allora che puoi chiamare l'applicazione un driver).
2. Il programma del driver richiede risorse al gestore cluster per avviare gli esecutori.
3. Il gestore cluster avvia gli esecutori.
4. Il processo del driver viene eseguito tramite l'applicazione utente. A seconda delle azioni e delle trasformazioni su RDD, l'attività viene inviata agli esecutori.
5. Gli esecutori eseguono le attività e salvano i risultati.
6. Se un lavoratore si arresta in modo anomalo, le sue attività verranno inviate a diversi esecutori per essere nuovamente elaborate. Nel libro "Learning Spark: analisi dei big data velocissima" parlano della Spark and Fault Tolerance:

Spark gestisce automaticamente le macchine guaste o lente rieseguendo le attività guaste o lente. Ad esempio, se il nodo che esegue una partizione di un'operazione map () si arresta in modo anomalo, Spark lo eseguirà nuovamente su un altro nodo; e anche se il nodo non si arresta in modo anomalo ma è semplicemente molto più lento di altri nodi, Spark può avviare preventivamente una copia "speculativa" dell'attività su un altro nodo e ottenere il suo risultato al termine.

7. Con SparkContext.stop () dal driver o se il metodo principale esce / si arresta in modo anomalo, tutti gli esecutori verranno chiusi e le risorse del cluster verranno rilasciate dal gestore cluster.

LE TUE DOMANDE

1. Quando vengono avviati gli esecutori, si registrano con il driver e da quel momento comunicano direttamente. I lavoratori hanno il compito di comunicare al gestore del cluster la disponibilità delle proprie risorse.

2. In un cluster YARN puoi farlo con --num -ecutors. In un cluster autonomo otterrai un esecutore per lavoratore a meno che tu non giochi con spark.executor.cores e un lavoratore abbia abbastanza core per contenere più di un esecutore. (Come sottolineato da @JacekLaskowski, --num -ecutors non è più in uso in YARN https://github.com/apache/spark/commit/16b6d18613e150c7038c613992d80a7828413e66 )

3. Puoi assegnare il numero di core per esecutore con --executor-core

4. --total -ecutor-cores è il numero massimo di core esecutori per applicazione

5. Come ha detto Sean Owen in questo thread : "non c'è una buona ragione per eseguire più di un lavoratore per macchina". Avresti molte JVM sedute in una macchina per esempio.

AGGIORNARE

Non sono stato in grado di testare questi scenari, ma secondo la documentazione:

ESEMPIO 1: Spark acquisirà avidamente tutti i core e gli esecutori offerti dallo scheduler. Quindi alla fine otterrai 5 esecutori con 8 core ciascuno.

ESEMPIO da 2 a 5: Spark non sarà in grado di allocare tutti i core richiesti in un singolo lavoratore, quindi non verranno lanciati esecutori.

Ecco come Apache Spark funziona internamente: