Raspberry Pi 4 Cluster, 16 Kerne und 16GB Arbeitsspeicher unser kleines Rechenleistungsmonster

erstellt am: 18.06.2020 | von: Markus | Kategorie(n): Bastelein, Projekte

Für diesen Beitrag habe ich meinem Jugendfreund für sein Studium ein Raspberry Pi Cluster geschenkt, damit er in seinem Studium (Master in Big Data) einen Leistungsstarken Rechner hat mit dem er schnell die Daten für seine Hausarbeiten und Aufgaben im Studium hat. Ich bat Ihn die Einrichtung für euch einmal aufzuschreiben, damit Ihr es nachbauen könnt und evtl. selbst eure Projekte realisieren kannst. Grundsätzlich ist das Cluster mit jeder Pi Version umzusetzen, aber um das Maximum an Leistung herauszuholen, haben wir hier mit dem Raspberry Pi 4 gearbeitet. Ab jetzt geht der Gastbeitrag für euch los.

Benötigte Utensilien

• 4x Raspberry Pi 4GB RAM* – Bei Pollin*/ Raspberry Pi 8GB RAM*
• 1x Gehäuse Rack für 4 Raspberry Pis mit Kühlung*  / Alternatives Gehäuse mit großen Lüfter*
• 1x USB Netzteil mit einzelnem Amper Output*
• 4x USB-C Kabel für die Stromversorgung des Pis*
• 4x Ethernet Kabel*
• 4x MicroSDXC Speicherkarten*
• 1x Switch*

Kosten etwa 340€ für die Einzelteile.

Was ist Big Data?

Big Data ist ein Buzzword welches in der Gesellschaft häufig genutzt wird. In diesem Bereich komme meisten teure Cloudlösungen zum Einsatz. Erfahrung in diesen Technologien zu sammeln, ohne in einem Unternehmen zu arbeiten, welche diese Cloudlösungen nutzt oder an ihnen arbeitet ist daher schwierig. Eine dieser Software ist Hadoop. Zusammen mit dem Dateisystem HDFS, ermöglicht es Hadoop, Daten auf einem Cluster verteilt zu speichern. Außerdem bietet es verschiedene Features bezüglich Ausfall Sicherheit der Daten und zur Vermeidung von Datenverlust. Gerade um einen Einstieg in die Vorteile der horizontalen Skalierbarkeit mit Hadoop-Clustern zu bekommen erfordert eine Infrastruktur bestehend aus mehreren Computern. Um auf diesem Cluster Datenanalysen durchzuführen, benötigt man eine Software wie Spark, welche mit Hadoop kommuniziert um Aufgaben verteilt über das Cluster durchzuführen.

Mittlerweile sind im freien Markt jedoch eine Vielzahl an erschwinglichen Einplatinencomputern im Angebot. Diese Mini-Computer wie z.B. ein Raspberry Pi (vierte Generation) ist für einen angemessenen Prei zu kaufen und biete alles, was man für den Aufbau seines eigenen Clusters braucht. Im folgenden Text erkläre ich wie ihr aus 4 Raspberry Pis, euch ein Hadoop Cluster aufbauen könnt und wie ihr mit Hilfe von Spark erste Daten Analysen durchführen könnt. Grundsätzlich könnt ihr zum Aufbau des Clusters eine beliebige Anzahl von Pi’s verwenden. In diesem Beispiel habe ich 4 Pi’s mit 4 GB RAM genutzt.

Installation des Pi Clusters

Als erstes installiert ihr auf den MicroSD Karten für jeden Pi das Betriebssystem Raspbian. Dazu folgt ihr der Anleitung der offiziellen Raspberry Pi Seite. Dort werden euch drei Versionen von Raspbian angeboten ich empfehle euch „Raspbian Buster with desktop and recommended software“ zu installieren. Als Hadoop Cluster brauchen wir den Desktop eigentlich nicht jedoch schadet er auch nicht und ihr könnt die einzelnen Pi’s bei Bedarf auch noch für andere Anwendungszwecke nutzen.

Ich kann dir vom Blog HelloCoding.de den Artikel „Raspberry Pi – Installation und Einrichtung“ Empfehlen, wenn du noch nicht viel Erfahrung mit dem Raspberry Pi hast.

Nach der Installation steckt ihr die steckt ihr die Speicherkarten in die Pis.

Installation von Java

Für die Installation der Software, benötigen wir Oracle Java 8. Dies lässt sich nicht standardmäßig über die Paketverwaltung installieren. Ihr müsst euch das Pakete manuell von der Oracle Webside downloaden. Öffnet diese Website und wählt dort das Linux ARM 32 Paket zum download aus. Solltet ihr bereits eines 64-Bit Version von Raspbian auf euren Pis installiert haben, dann downloadet euch das Linux ARM 64 Paket. Vor dem Download müsst ihr euch jedoch einen kostenlosen Account erstellen. Kopiert das Paket auf alle eure Pis in das Verzeichnis /home/pi . Nun führt ihr abwechselnd auf allen euren Pis folgende Befehle aus:

sudo mkdir /usr/java cd /usr/java sudo tar xf /home/pi/ jdk-8u251-linux-arm32-vfp-hflt.tar.gz
sudo update-alternatives --install /usr/bin/javac javac /usr/java/jdk1.8.0_251/bin/javac 1000
sudo update-alternatives --install /usr/bin/java java /usr/java/jdk1.8.0_251/bin/java 1000

Als letzter führ ihr nun folgenden Befehl aus, wo ihr die Oracle Java Version auswählen müsst:

sudo update-alternatives --config java

Grundkonfiguration des Clusters

Nachdem wir die richtige Java Version installiert haben, beginnen wir damit ein paar Werkzeuge zu konfigurieren, die das gleichzeitige Arbeiten mit 4 Pi’s vereinfacht, und gleichzeitig schon ein paar Konfigurationen für Hadoop und Spark vorne wegnehmen:

Dafür führt ihr auf jedem Pi nano ~/bashrc aus und fügt dort folgendes ein:

export JAVA_HOME=/usr/java/jdk1.8.0_251
export HADOOP_HOME=/opt/hadoop
export PATH=$PATH:$HADOOP_HOME/bin:$HADOOP_HOME/sbin
export SPARK_HOME=/opt/spark
export PATH=$PATH:$SPARK_HOME/bin
export HADOOP_CLASSPATH=${JAVA_HOME}/lib/tools.jar
export HADOOP_CONF_DIR=$HADOOP_HOME/etc/hadoop
export LD_LIBRARY_PATH=$HADOOP_HOME/lib/native:$LD_LIBRARY_PATH
function otherpis {
grep "pi" /etc/hosts | awk '{print $2}' | grep -v $(hostname)
}
function clustercmd {
for pi in $(otherpis); do ssh $pi "$@"; done
$@
}
function clusterreboot {
clustercmd sudo shutdown -r now
}
function clustershutdown {
clustercmd sudo shutdown now
}
function clusterscp {
for pi in $(otherpis); do
cat $1 | ssh $pi "sudo tee $1" > /dev/null 2>&1
done
}

Anschließend müsst ihr ebenfalls auf allen Pis folgenden Befehl ausführen, um die Änderungen in der bashrc gültig zu machen:

source ~/.bashrc

Benennung (Hostnames) der Raspberry Pis

Nun wollen wir jedem einzelnen Pi einen eindeutigen Hostnamen zuweisen. Dafür loggt ihr euch per SSH auf jedem der Pis nacheinander ein und führt folgenden Befehl aus:

sudo nano /etc/hosts
(IP-Adresse1) pi1
(IP-Adresse2) pi2
(IP-Adresse3) pi3
(IP-Adresse4) pi4

Nutzt ihr in eurem Cluster mehr als vier Pis müsst ihr diese Liste entsprechend erweitern.

Ebenfalls müsst ihr auf allen Pi’s den Hostnamen anpassen dafür macht ihr folgendes:

sudo nano /etc/hostname 
PiX

Nun habt ihr allen Pis einen eindeutigen Hostname zugewiesen und die Hostnames über alle andere bekannt gemacht.

Als nächste vereinfachen wir das einloggen per SSH. Dafür müssen wir als erstes in der SSH Konfiguration einen Alias für jeden Pi innerhalb des Clusters anlegen. Dafür führen wir folgenden Befehl aus:

nano ~/.ssh/config

Dort fügen wir nun folgendes ein:

Host PiX
User pi
Hostname (IP-Adresse PiX)

Das X ersetzt ihr durch den jeweiligen Pi und fügt nach „Hostname“ die entsprechende IP Adresse ein. Fügt in diese Liste alle eure Pis ein und kopiert sie auf alle anderen Pis.

Um nun noch die ständige Passwort Eingabe zu vermeiden, generieren wir nun für jeden Pi einen SSH-Key. Dafür führt ihr auf jedem Pi folgenden Befehl aus:

ssh-keygen –t ed25519

Dieser Befehl erzeugt die Datei id_ed25519.pub und id_ed25519. Zweiteres ist der private Key und sollte seinen Client niemals verlassen! Die .pub Datei enthält den public key und dieser muss nun unter allen Pis verteilt werden. Mit dem Befehl:

cat ~/.ssh/id_ed25519.pub | ssh piX@192.168.0.101 'cat >> .ssh/authorized_keys'

Diesen Befehl führt ihr auf jedem Pi so oft aus bis ihr die Datei auf allen anderen Pis kopiert. Dann wechselt ihr zu eurem nächsten Pi und führt den Schritt erneut aus usw.

Nun ist das Cluster so konfiguriert, dass man von einem Pi aus, ein Befehl auf allen Pis ausführen kann. In der bashrc sind mehrer dieser Clusterkomandos konfiguriert.

Mit dem Befehl:

clustercmd date

Bekommt ihr von allen Pis die aktuelle Uhrzeit geschickt. Wenn ihr diesen Befehl ausführt, werdet ihr merken, dass die Uhrzeiten unterschiedliche sind. Um dies zu synchronisieren, führt ihr folgende Befehle aus:

clustercmd "sudo apt install htpdate -y > /dev/null 2>&1"
clustercmd sudo htpdate -a -l time.nist.gov
clustercmd date

Nun können wir endlich damit starten, dass eigentliche Hadoop Cluster zu installieren. Zum Downloaden der Software führt ihr folgenden Befehl aus:

cd && wget https://downloads.apache.org/hadoop/common/hadoop-3.2.1/hadoop-3.2.1.tar.gz
sudo tar -xvf hadoop-3.2.1.tar.gz -C /opt/
rm hadoop-3.2.1.tar.gz && cd /opt
sudo mv hadoop-3.2.1 hadoop
sudo chown pi:pi -R /opt/hadoop

Nun müssen benötigte Verzeichnisse auf allen Pis angelegt werden. Dies lässt sich mit folgendem Befehl durchführen:

clustercmd sudo mkdir -p /opt/hadoop_tmp/hdfs
clustercmd sudo chown pi:pi –R /opt/hadoop_tmp
clustercmd sudo mkdir -p /opt/hadoop
clustercmd sudo chown pi:pi /opt/hadoop

Im nächsten Schritt muss das Cluster konfiguriert werden. Alle Dateien die dafür angepasst werden müssen, befinden sich im Verzeichnis /opt/hadoop/etc/hadoop .

Konfiguration von Hadoop

Den Inhalt der Datei core-site.xml ersetzt ihr durch folgendes:

<configuration>
<property>
<name>fs.default.name</name>
<value>hdfs://pi1:9000</value>
</property>
</configuration>

Den Inhalt der Datei hdfs-site.xml ersetzt ihr durch:

<configuration>
<property>
<name>dfs.datanode.data.dir</name>
<value>file:///opt/hadoop_tmp/hdfs/datanode</value>
</property>
<property>
<name>dfs.namenode.name.dir</name>
<value>file:///opt/hadoop_tmp/hdfs/namenode</value>
</property>
<property>
<name>dfs.replication</name>
<value>4</value>
</property>
</configuration>

Den Inhalt der Datei mapred-site.xml ersetzt ihr durch:

<configuration>
<property>
<name>mapreduce.framework.name</name>
<value>yarn</value>
</property>
<property>
<name>yarn.app.mapreduce.am.resource.mb</name>
<value>3072</value>
</property>
<property>
<name>mapreduce.map.memory.mb</name>
<value>3072</value>
</property>
<property>
<name>mapreduce.reduce.memory.mb</name>
<value>3072</value>
</property>
<property>
<name>yarn.app.mapreduce.am.env</name>
<value>HADOOP_MAPRED_HOME=$HADOOP_HOME</value>
</property>
<property>
<name>mapreduce.map.env</name>
<value>HADOOP_MAPRED_HOME=$HADOOP_HOME</value>
</property>
<property>
<name>mapreduce.reduce.env</name>
<value>HADOOP_MAPRED_HOME=$HADOOP_HOME</value>
</property>
</configuration>

Und zum Schluss ersetz ihr den Inhalt der Datei yarn-site.xml durch folgendes:

<configuration>
<property>
<name>yarn.acl.enable</name>
<value>0</value>
</property>
<property>
<name>yarn.resourcemanager.hostname</name>
<value>pi1</value>
</property>
<property>
<name>yarn.nodemanager.aux-services</name>
<value>mapreduce_shuffle</value>
</property>
<property>
<name>yarn.nodemanager.auxservices.mapreduce.shuffle.class</name>
<value>org.apache.hadoop.mapred.ShuffleHandler</value>
</property>
<property>
<name>yarn.nodemanager.resource.memory-mb</name>
<value>3072</value>
</property>
<property>
<name>yarn.scheduler.maximum-allocation-mb</name>
<value>3072</value>
</property>
<property>
<name>yarn.scheduler.minimum-allocation-mb</name>
<value>64</value>
</property>
<property>
<name>yarn.nodemanager.vmem-check-enabled</name>
<value>false</value>
</property>
</configuration>

Anschließend muss auf dem Pi1 noch zwei Dateien in dem Verzeichnis /opt/hadoop/etc/hadoop erstellt werden. In der Datei master fügt ihr „pi1“ hinzu. In der Datei workers fügt ihr eure anderen Pis hinzu. In meinem Fall also:

• pi2
• pi3
• pi4

Nun kopiert ihr alle Daten von Hadoop von eurem Pi1 auf alle anderen Pis. Die könnt ihr mit folgendem Befehl durchführen:

for pi in $(otherpis); do rsync –avxP $HADOOP_HOME $pi:/opt; done

Ist dies auch erledigt ist die Installation von Hadoop abgeschlossen. Ich empfehle nun einen Neustart des Clusters und anschließen könnt ihr auf eurem Pi1 das Hadoop Cluster starten, in dem ihr folgenden Befehl ausführt:

start-dfs.sh && start-yarn.sh

Über den Webbrowser könnt ihr nun prüfen, ob euer Cluster funktioniert. Dafür ruft ihr einfach folgendes auf:

http://IP-Adresse-Pi1:9870

Auf dieser Weboberfläche bekommt ihr alle wichtigen Informationen zu eurem Cluster. Ihr könnt hier unter anderem auch neue Daten im HDFS speichern.

Installation von Spark

Als nächstes installieren wir Spark. Dafür führt ihr folgenden Befehle aus:

wget https://downloads.apache.org/spark/spark-3.0.0-preview2/spark-3.0.0-preview2-bin-hadoop3.2.tgz
sudo tar –xvf spark-3.0.0-preview2-bin-hadoop3.2.tgz –C /opt/
rm spark-3.0.0-preview2-bin-hadoop3.2.tgz && cd /opt
sudo mv spark-3.0.0-preview2-bin-hadoop3.2 spark
sudo chown pi:pi -R /opt/spark

Um zu überprüfen ob Spark erfolgreich installiert wurde, führen wir folgenden Befehl aus

cd && spark-shell –version

Damit Spark das Hadoop-Cluster nutzen kann, muss es mit YARN kommunizieren können. Dafür müssen wir die Spark Konfigurationsdatei erstellen und anpassen. Führt dafür folgende Befehle aus:

cd $SPARK_HOME/conf
sudo mv spark-defaults.conf.template spark-defaults.conf
nano spark-defaults.conf

Hier fügt ihr nun folgenden Text ein:

spark.master yarn
spark.driver.memory 1024m
spark.yarn.am.memory 512m
spark.executor.memory 512m
spark.executor.cores 4

Benötigt ihr mehr Arbeitsspeicher für eure Jobs könnt ihr hier später noch Anpassungen vornehmen.

Damit ist Spark konfiguriert und einsatzbereit. Stoppt erst einmal das Hadoop-Cluster mit dem Befehl:

stop-dfs.sh && stop-yarn.sh

Anschließend könnt ihr es wieder starten mit:

start-dfs.sh && start-yarn.sh

Um nun final zu prüfen ob eure gesamte Infrastruktur (Hadoop-Cluster und Spark) funktioniert, könnt ihr einen Spark-Job ausführen der euch Pi auf einige Nachkommastellen genau berechnet. Dafür führt ihr folgenden Befehl aus:

spark-submit --deploy-mode cluster --master yarn --class org.apache.spark.examples.SparkPi $SPARK_HOME/examples/jars/spark-examples_2.11-2.4.5.jar 7