Come definire una variabile di lettura/scrittura globale in Spark

Question

Spark ha variabili broadcast, che sono di sola lettura e accumulator, che possono essere aggiornamenti dai nodi, ma non letti. C'è un modo o una soluzione per definire una variabile che è sia aggiornabile che leggibile?

Un requisito per tale variabile globale di lettura/scrittura sarebbe l'implementazione di una cache. Poiché i file vengono caricati ed elaborati come rdd, vengono eseguiti i calcoli. I risultati di questi calcoli - che si verificano in diversi nodi che corrono in parallelo - devono essere inseriti in una mappa, che ha come chiave alcuni degli attributi dell'entità in fase di elaborazione. Mentre le entità successive all'interno di rdd vengono elaborate, la cache viene interrogata.

Scala ha ScalaCache, che è una facciata per implementazioni di cache come Google Guava. Ma come si dovrebbe includere e accedere a tale cache all'interno di un'applicazione Spark?

La cache può essere definita come una variabile nell'applicazione driver che crea lo SparkContext. Ma poi ci sarebbero due questioni:

• prestazioni sarebbe presumibilmente male a causa del sovraccarico di rete tra i nodi e l'applicazione del driver.
• A mio parere, a ogni rdd verrà passata una copia della variabile (cache in questo caso) quando si accede per la prima volta alla variabile dalla funzione passata a rdd. Ogni rdd dovrebbe avere la propria copia, non l'accesso a una variabile globale condivisa.

Qual è il modo migliore per implementare e archiviare una cache di questo tipo?

Grazie

Answer 1

Bene, il miglior modo di fare questo non sta facendo in tutto. In generale, Spark modello di elaborazione non fornisce alcuna garanzia circa

• dove,
• quando,
• in quale ordine (escludendo ovviamente l'ordine delle trasformazioni definiti dal lignaggio/DAG)
• e quante volte

dato un pezzo di codice viene eseguito. Inoltre, tutti gli aggiornamenti che dipendono direttamente dall'architettura Spark, non sono granulari.

Queste sono le proprietà che rendono Spark scalabile e resiliente ma allo stesso tempo questo è ciò che rende molto difficile implementare uno stato mutevole condiviso e il più delle volte completamente inutile.

Se quello che cercate è un semplice cache di poi si dispone di più opzioni:

• uso uno dei metodi descritti da Tzach Zohar in Caching in Spark
• uso caching locale (per JVM o filo esecutore) in combinazione con applicazioni partizionamento specifico per mantenere le cose locali
• per la comunicazione con sistemi esterni utilizzano nodo cache locale indipendente Spark (per esempio di proxy Nginx per le richieste hTTP)

Se l'applicazione richiede molto più complessa di comunicazione si può provare messaggio diverso strumenti passando per mantenere stato sincronizzato, ma in generale si richiede un codice complesso e potenzialmente fragili.