1. Zusammenfassung der Spark-Eintrittsfälle
1. Lesen Sie die Datei:
textFile(path): Liest externe Datenquellen und unterstützt lokale Dateisysteme und HDFS-Dateisysteme.
2. Ergebnisdaten in eine Datei ausgeben:
saveAsTextFile(path): Gibt Daten an ein externes Speichersystem aus und unterstützt lokale Dateisysteme und HDFS-Dateisysteme.
3. Dateipfadprotokoll:
Lokal:Datei///Pfad
hdfs:hdfs://IP-Adresse der virtuellen Maschine:8020/Pfad
4. Sortieren verwandter APIs:
sortBy(Parameter 1, Parameter 2):
Parameter 1: Sie müssen angeben, nach was die Funktion sortiert werden soll.
Parameter 2: Standardmäßige aufsteigende Reihenfolge, boolescher Typ, optional
sortByKey(Parameter 1): Sortiert nach Schlüssel des Schlüssel-Wert-Paares
Parameter 1: Standardmäßige aufsteigende Reihenfolge, boolescher Typ, optional
top(N, Funktion):
N: Nehmen Sie die ersten paar Elemente in absteigender Reihenfolge
Funktion: Standardmäßig wird der Schlüssel nach dem Schlüssel des Schlüssel-Wert-Paares sortiert. Über die Funktion können andere Sortiermethoden angegeben werden. Der Rückgabewert ist eine Liste.
5. Andere verwandte APIs/Operatoren
flatMap (Funktion): Konvertieren Sie Elemente gemäß der angegebenen Funktion und unterstützen Sie die Konvertierung eines Elements in mehrere Elemente
Karte (Funktion): Konvertiert Elemente gemäß der angegebenen Funktion, unterstützt Eins-zu-Eins-Konvertierungsvorgänge, übergibt eins und gibt eins zurück
reduByKey (Funktion): Gruppieren Sie zuerst nach dem Schlüssel des Schlüssel-Wert-Paares, führen Sie die Wertwerte desselben Schlüssels in einer Liste zusammen und führen Sie dann die übergebene Funktion aus. Parameter 1 stellt das lokale Aggregationsergebnis dar. und der Standardwert ist das erste Element der Liste; Parameter 2 stellt den Wert in jeder durchlaufenen Liste dar, standardmäßig beginnend mit dem zweiten.
sammeln (): Sammeln, sammeln Sie alle Ergebnisdaten im Programm und erstellen Sie eine Liste für die Rückgabe.
2.Spark On Yarn-Umgebungskonfiguration
1. Die Essenz von Spark On Yarn
Spark konzentriert sich auf verteiltes Computing und Yarn auf Ressourcenmanagement. Spark übergibt die Ressourcenmanagementarbeit an Yarn.
2. Senden Sie die Anwendungsüberprüfungsumgebung
Senden Sie den geschriebenen WordCount-Code zur Ausführung an die Yarn-Plattform
Hinweis 1: Sie müssen den Parameterwert von setMaster in Yarn ändern oder den setMaster-Code direkt löschen
Hinweis 2: Der Inhalt im Zusammenhang mit dem Dateipfad im Code muss geändert werden, um verteilte Dateisysteme wie HDFS lesen und schreiben zu können. Da das Programm verteilt ausgeführt wird, können wir nicht sicherstellen, dass jeder Knoten denselben lokalen Dateipfad hat . verursacht einen Fehler.
cd /export/server/spark/bin
./spark-submit --master Yarn \
--conf "spark.pyspark.driver.python=/root/anaconda3/bin/python3" \
--conf "spark.pyspark.python=/root/anaconda3/bin/python3" \
/export/data/gz16_pyspark/01_spark_core /src/05_spark_on_yarn_test.pyHinweis: Ändern Sie den Codepfad in Ihren eigenen
3. Zwei Möglichkeiten, Protokolle anzuzeigen
①Sehen Sie sich den 18080-Protokollserver von Spark an
②Sehen Sie sich die 8088-Schnittstelle von Yarn an
4.Zwei Bereitstellungsmethoden von Spark On Yarn
In Spark gibt es zwei Bereitstellungsmethoden: Client und Cluster. Die Standardeinstellung ist Client. Der wesentliche Unterschied zwischen den beiden besteht im Speicherort, an dem der Treiberprozess gestartet und ausgeführt wird.
Client-Bereitstellungsmodus: Der Treiberprozess wird auf dem Computer ausgeführt, auf dem das Programm übermittelt wird
Vorteile: Alle Laufergebnisse und Laufprotokolle werden zur einfachen Anzeige an den Computer ausgegeben, an den das Programm übermittelt wird.
Nachteile: Der Treiberprozess und der Garncluster befinden sich möglicherweise nicht im selben Cluster, was dazu führt, dass der Datenaustausch zwischen dem Treiberprozess und dem Executorprozess ineffizient ist.
Verwendung: Wird im Allgemeinen in der Entwicklung und beim Testen verwendet
Spezifischer Code:
./spark-submit --master Yarn \
--deploy-mode client \
--conf "spark.pyspark.driver.python=/root/anaconda3/bin/python3" \
--conf "spark.pyspark.python=/ root/anaconda3/bin/python3" \
/export/data/gz16_pyspark/01_spark_core/src/05_spark_on_yarn_test.py
Cluster-Bereitstellungsmethode: Der Treiberprozess wird auf einem Slave-Knoten im Cluster ausgeführt
Vorteile: Der Treiberprozess und der Garncluster befinden sich im selben Cluster, und die Effizienz des Datenaustauschs zwischen dem Treiberprozess und dem Executorprozess ist relativ hoch.
Nachteile: Sie müssen die Seiten 18080 und 8088 aufrufen, um die Protokolle und Laufergebnisse anzuzeigen.
Verwendung: Wird im Allgemeinen in Produktionsumgebungen verwendet
Spezifischer Code:
./spark-submit --master Yarn \
--deploy-mode Cluster \
--conf "spark.pyspark.driver.python=/root/anaconda3/bin/python3" \
--conf "spark.pyspark.python=/ root/anaconda3/bin/python3" \
/export/data/gz16_pyspark/01_spark_core/src/05_spark_on_yarn_test.py
3. Spark-Submit-Befehl
Anschließend müssen Sie das von Ihnen geschriebene Spark-Programm an die entsprechende Ressourcenplattform senden, zum Beispiel: lokaler Garn-Spark-Cluster (eigenständig)
Um die Aufgabenübermittlung zu erleichtern, stellt Spark eine Skriptdatei für die Aufgabenübermittlung bereit: spark-submit
Während des Übermittlungsprozesses legt Spark-Submit viele Parameter fest und passt aufgabenbezogene Informationen an. **Wenn Sie es vergessen, können Sie es mit spark-submit --help überprüfen
4. Interaktionsprozess zwischen PySpark-Programm und Spark
1.Client im Spark-Cluster
① Wo immer Sie das Programm senden, wird der Treiberprozess irgendwo gestartet.
②Nachdem der Treiberprozess gestartet wurde, handelt es sich um einen JVM-Prozess, der Python-Code nicht direkt ausführen kann. Die unterste Ebene basiert auf PY4J, das den Code zum Erstellen von SparkContext-Objekten zur Erstellung auf Java abbildet.
③Der Treiberprozess stellt eine Verbindung zum Master-Knoten im Spark-Cluster her und beantragt gemäß den Ressourcenkonfigurationsanforderungen Ressourcen vom Master-Knoten, um den Executor zu starten.
④Nach Erhalt der Ressourcenanwendung weist der Masterknoten Ressourcen zu. Die unterste Schicht basiert auf FIFO (First In, First Out). Nach der Zuweisung der Ressourcen wird der Plan an den Treiberprozess zurückgegeben.
Executor1:Knoten1 2G 2CPU
Executor2:Knoten3 2G 2CPU
⑤Der Treiber stellt eine Verbindung zum entsprechenden Worker-Slave-Knoten her und belegt die entsprechenden Ressourcen. Benachrichtigt den Worker, den Executor-Prozess zu starten. Nach dem Start wird er umgekehrt wieder beim Treiber registriert.
⑥Der Treiber beginnt mit der Codeverarbeitung
1) Der Treiber lädt RDD-bezogene Operatoren, zeichnet einen DAG-gesteuerten azyklischen Graphen, unterteilt die Stufe entsprechend den Abhängigkeiten zwischen den Operatoren und bestimmt, wie viele Task-Threads jede Stufe hat und diesen Executoren zur Ausführung zugewiesen werden muss.
2) Der Treiber benachrichtigt den entsprechenden Executor-Prozess, die entsprechende Aufgabe auszuführen
3) Executor beginnt mit der Ausführung bestimmter Aufgaben, stellt jedoch fest, dass der Code eine große Anzahl von Python-Funktionen enthält. Executor ist ein JVM-Prozess und kann den Code nicht direkt ausführen. Daher ruft er den Python-Interpreter auf dem Server auf Übertragen Sie die Python-Funktionen und Eingabedaten an Python. Der Interpreter gibt nach der Ausführung die Ergebnisdaten an den Executor-Prozess zurück.
4) Während des laufenden Prozesses bestimmt der Executor, ob die Ergebnisdaten an den Treiberprozess zurückgegeben werden müssen. Bei Bedarf werden sie an den Treiberprozess zurückgegeben. Wenn nicht, werden sie direkt ausgegeben und beendet.
5) Der Treiber überprüft regelmäßig den Ausführungsstatus mehrerer Executoren. Bis alle Executoren ausgeführt sind, gilt die Aufgabe als beendet.
⑦Driver ruft den sc.stop()-Code auf, um den Master zu benachrichtigen, Ressourcen zu recyceln, und das gesamte Programm wird beendet.
2. Cluster auf Spark-Cluster
Der Unterschied: Der Treiberprozess wird nicht auf dem Computer ausgeführt, der die Aufgabe übermittelt hat, sondern wählt zufällig einen Worker-Slave-Knoten im Spark-Cluster aus, um den Treiberprozess zu starten und auszuführen.
1- Senden Sie die Aufgabe an den Masterknoten-Master des Spark-Clusters
2- Nach Erhalt der Aufgabeninformationen wählt der Masterknoten gemäß den Ressourcenkonfigurationsanforderungen des Treibers zufällig einen Worker-Slave-Knoten im Cluster aus (zufällig ausgewählt aus vielen Slave-Knoten mit ausreichenden Ressourcen), um den Treiberprozess zu starten und auszuführen.
3- Führen Sie nach dem Start des Treiberprozesses die Hauptfunktion aus und erstellen Sie zunächst das SparkContext-Objekt. Die unterste Ebene basiert auf PY4J, das den Code zum Erstellen von SparkContext-Objekten zur Erstellung auf Java abbildet.
4- Der Treiberprozess stellt eine Verbindung zum Master-Knoten im Spark-Cluster her und beantragt Ressourcen vom Master-Knoten gemäß den Ressourcenkonfigurationsanforderungen, um den Executor zu starten.
5- Nach Erhalt der Ressourcenanwendung weist der Masterknoten Ressourcen zu. Die unterste Schicht basiert auf FIFO (First In, First Out). Geben Sie den Plan nach der Zuweisung von Ressourcen an den Treiberprozess
Executor1: Knoten1 2G 2CPU
Executor2: Knoten3 2G 2CPU zurück
6-Driver stellt eine Verbindung zum entsprechenden Worker-Slave-Knoten her und belegt die entsprechenden Ressourcen. Benachrichtigen Sie den Worker, um den Executor-Prozess zu starten. Nach dem Start wird es in umgekehrter Reihenfolge wieder beim Treiber registriert.
7-Driver beginnt mit der Verarbeitung von Code
7.1- Driver lädt RDD-bezogene Operatoren, zeichnet einen DAG-gesteuerten azyklischen Graphen und unterteilt Stage-Stufen basierend auf den Abhängigkeiten zwischen Operatoren und bestimmt, wie viele Task-Threads es in jeder Stage-Stufe gibt. Welcher Executor zur Ausführung zugewiesen werden muss.
7.2 – Der Treiber benachrichtigt den entsprechenden Executor-Prozess, die entsprechende Aufgabe auszuführen.
7.3 – Der Executor beginnt mit der Ausführung bestimmter Aufgaben. Es wurde jedoch festgestellt, dass der Code eine große Anzahl von Python-Funktionen enthält und der Executor ein JVM-Prozess ist und den Code nicht direkt ausführen kann. Daher wird der Python-Interpreter auf dem Server aufgerufen und die Python-Funktion und Eingabedaten werden an den Python-Interpreter übertragen. Nach der Ausführung werden die Ergebnisdaten an den Executor-Prozess zurückgegeben.
7.4- Während des laufenden Prozesses wird der Executor dies tun Bestimmen Sie, ob die Ergebnisdaten zurückgegeben werden müssen. Geben Sie sie an den Treiberprozess weiter. Geben Sie es bei Bedarf an den Treiberprozess zurück. Wenn nicht, geben Sie es direkt aus und beenden Sie es.
7.5 – Der Treiber überprüft regelmäßig den Ausführungsstatus mehrerer Ausführender. Bis alle Executoren ausgeführt sind, gilt die Aufgabe als abgeschlossen.
8- Der Treiber ruft den sc.stop()-Code auf, um den Master zu benachrichtigen, dass er Ressourcen recyceln soll. Das gesamte Programm endet.
3.Client auf Garncluster
Der Unterschied: Die Arbeit der Ressourcenanwendung im Driver-Prozess wird an den ApplicationMaster von Yarn übertragen. Der Driver ist hauptsächlich für die Aufgabenzuweisung und Aufgabenverwaltung verantwortlich.
1- Zunächst wird ein Treiberprozess auf dem übermittelten Knoten gestartet.
2- Führen Sie nach dem Start des Treiberprozesses die Hauptfunktion aus und erstellen Sie zunächst das SparkContext-Objekt. Die unterste Ebene basiert auf PY4J, das den Code zum Erstellen von SparkContext-Objekten zur Erstellung auf Java abbildet.
3- Stellen Sie eine Verbindung zum Hauptknoten des Yarn-Clusters (ResourceManager) her, kapseln Sie die Ressourcen, die beantragt werden müssen, in eine Aufgabe und senden Sie sie an den Hauptknoten von Yarn. Nach Erhalt der Aufgabe wählt der Masterknoten zunächst zufällig einen Slave-Knoten (NodeManager) aus, um ApplicationMaster zu starten.
4- Wenn ApplicationMaster startet, richtet es einen Heartbeat-Mechanismus mit dem Yarn-Master-Knoten ein, um zu benachrichtigen, dass der Start erfolgreich war. Nach erfolgreichem Start wird der Ressourcenantragsprozess durchgeführt und die zu beantragenden Ressourcen in Form von Heartbeat-Paketen an den Masterknoten gesendet. Nach Erhalt der Ressourcenanwendung beginnt der Masterknoten mit der Ressourcenzuweisung. Die unterste Ebene wird basierend auf dem Ressourcenplaner implementiert (der Standardwert ist der Kapazitätsplaner). Nachdem der Masterknoten die Ressourcenzuweisung abgeschlossen hat, wartet er darauf, dass ApplicationMaster Ressourcen abruft. ApplicationMaster fragt den Masterknoten regelmäßig durch Heartbeats, ob er Ressourcen vorbereitet hat. Sobald festgestellt wird, dass es bereit ist, werden die entsprechenden Ressourceninformationen sofort abgerufen.
5- ApplicationMaster stellt basierend auf den abgerufenen Ressourceninformationen eine Verbindung zum entsprechenden Slave-Knoten her. Belegen Sie die entsprechenden Ressourcen und benachrichtigen Sie den Slave-Knoten, um den Executor-Prozess zu starten. Nachdem der Executor vom Knoten aus gestartet wurde, wird er wieder beim Treiberprozess registriert.
6-Treiber beginnt mit der Verarbeitung von Code
6.1- Der Treiber lädt RDD-bezogene Operatoren, zeichnet einen DAG-gesteuerten azyklischen Graphen und unterteilt Stage-Stufen basierend auf den Abhängigkeiten zwischen Operatoren und bestimmt, wie viele Task-Threads es in jeder Stage-Stufe gibt. Welcher Executor zur Ausführung zugewiesen werden muss.
6.2 – Der Treiber benachrichtigt den entsprechenden Executor-Prozess, um die entsprechende Aufgabe auszuführen.
6.3 – Der Executor beginnt mit der Ausführung bestimmter Aufgaben. Es wurde jedoch festgestellt, dass der Code eine große Anzahl von Python-Funktionen enthält und der Executor ein JVM-Prozess ist und den Code nicht direkt ausführen kann. Daher wird der Python-Interpreter auf dem Server aufgerufen und die Python-Funktion und Eingabedaten werden an den Python-Interpreter übertragen. Nach der Ausführung werden die Ergebnisdaten an den Executor-Prozess zurückgegeben.
6.4- Während des laufenden Prozesses wird der Executor dies tun Bestimmen Sie, ob die Ergebnisdaten zurückgegeben werden müssen. Geben Sie sie an den Treiberprozess weiter. Geben Sie es bei Bedarf an den Treiberprozess zurück. Wenn nicht, geben Sie es direkt aus und beenden Sie es.
6.5 – Der Treiber überprüft regelmäßig den Ausführungsstatus mehrerer Ausführender. Bis alle Executoren ausgeführt sind, gilt die Aufgabe als abgeschlossen. Gleichzeitig empfängt ApplicationMaster auch den Ausführungsabschlussstatus jedes Knotens und benachrichtigt dann den Masterknoten. Nachdem die Aufgabenausführung abgeschlossen ist, fordert der Masterknoten Ressourcen zurück, schließt ApplicationMaster und benachrichtigt den Treiber.
7- Der Treiber führt den sc.stop()-Code aus. Der Treiberprozess wird beendet
4. Cluster auf Garncluster
Unterschied: Im Cluster-Modus werden die Funktionen des Driver-Prozesses und die Funktionen (Rollen) des ApplicationMaster zu einer zusammengefasst. Der Driver ist der ApplicationMaster und der ApplicationMaster ist der Driver. Er ist sowohl für die Ressourcenanwendung als auch für die Aufgabenzuweisung verantwortlich Management.
1- Zuerst wird die Aufgabe an den Masterknoten des Yarn-Clusters (ResourceManager) übermittelt.
2- Nach Erhalt der Aufgabeninformationen wählt ResourceManager einen
NodeManager-Knoten (mit Ressourcen, wenn beide zufällig sind) gemäß den Ressourcenkonfigurationsinformationsanforderungen von Driver (ApplicationMaster) aus, um das Driver (ApplicationMaster)-Programm zu starten und die entsprechenden Ressourcen zu belegen.
3- Nachdem der Treiber (ApplicationMaster) gestartet ist, führen Sie die Hauptfunktion aus. Erstellen Sie zunächst ein SparkContext-Objekt (die unterste Ebene basiert auf PY4J, das
die Konstruktionsmethode von Python erkennt und sie dem Java-Code zuordnet). Nach erfolgreicher Erstellung wird ein Heartbeat-Mechanismus für den ResourceManager eingerichtet, um ihn über den
erfolgreichen Start zu informieren.
4- Beantragen Sie gemäß den Ressourcenkonfigurationsanforderungen des Executors Ressourcen vom ResourceManager über Heartbeat, um den Executor zu starten (
beim Senden einer Aufgabe können Sie die Ressourceninformationen anpassen).
5- Nach Erhalt des Ressourcenantrags weist ResourceManager Ressourcen entsprechend den Anwendungsanforderungen zu. Die unterste Ebene ist die Ressourcenzuweisung basierend auf dem Ressourcenplaner (der Standardwert
ist Kapazitätsplanung). Bereiten Sie dann die zugewiesenen Ressourcen vor und warten Sie, bis der Treiber (ApplicationMaster) den Vorgang abruft.
Executor1: Knoten1, 2 CPUs, 2 GB Speicher,
Executor2: Knoten3, 2 CPUs, 2 GB Speicher
6- Der Treiber (ApplicationMaster) fragt regelmäßig, ob die Ressource bereit ist, und ruft sie sofort ab, sobald sie bereit ist. Verbinden Sie den entsprechenden
Knoten gemäß den Ressourceninformationen, benachrichtigen Sie den NodeManager, um den Executor zu starten, und belegen Sie die entsprechenden Ressourcen. Nachdem der dem nodeManager entsprechende Executor gestartet wurde,
wird die umgekehrte Registrierung an das Treiberprogramm (ApplicationMaster) zurückgegeben (wurde gestartet).
7- Treiber (ApplicationMaster) beginnt mit der Verarbeitung des Codes:
7.1 Zunächst lädt er alle RDD-bezogenen APIs (Operatoren), erstellt ein DAG-Ausführungsflussdiagramm basierend auf den Abhängigkeiten zwischen Operatoren, teilt die
Stufen und bestimmt, wie viele Threads jede Stufe hat ausgeführt werden soll und welcher Executor jedem Thread zur Ausführung zugewiesen werden soll (Aufgabenzuweisung).
7.2 Das Treiberprogramm (ApplicationMaster) benachrichtigt das entsprechende Executor-Programm, um bestimmte Aufgaben auszuführen.
7.3 Nachdem der Executor die Aufgabeninformationen erhalten hat, startet er den Thread und beginnt mit der Ausführung Verarbeiten: Wenn der Executor ausgeführt wird,
ist der Executor ein JVM-Programm und kann Python-Funktionen nicht analysieren, da der RDD-Code eine große Anzahl von Python-Funktionen enthält. Zu diesem Zeitpunkt wird der Python-Parser aufgerufen, und die Funktion
ausgeführtwird , und das Funktionsergebnis wird zurückgegeben. An Executor
7.4 Wenn während des laufenden Prozesses von Executor festgestellt wird, dass das Endergebnis an Driver (ApplicationMaster) zurückgegeben werden muss, kehren Sie direkt zu
Driver (ApplicationMaster) zurück. Wenn nein Sie müssen zurückkehren und das Ende einfach direkt ausgeben.
7.5 Das Programm „Treiber (ApplicationMaster)“ überwacht die Ausführung dieses Executors. Statusinformationen: Wenn alle Executoren ausgeführt werden,
geht Driver (ApplicationMaster) davon aus, dass die Aufgabe abgeschlossen ist.
8- Wenn die Aufgabenausführung abgeschlossen ist, führt der Treiber sc.stop() aus, um den ResourceManager darüber zu informieren, dass die Ausführung abgeschlossen ist, der ResourceManager recycelt die Ressourcen und das
Treiberprogramm wird beendet.