16. Juni 2024 11 Minuten Lesezeit Nachrichten

So führen Sie Apache Spark auf Kubernetes in weniger als 5 Minuten aus

Tools wie Ilum werden einen großen Beitrag zur Vereinfachung des Prozesses der Installation von Apache Spark auf Kubernetes leisten. In diesem Leitfaden erfahren Sie Schritt für Schritt, wie Sie Spark gut auf Ihrem Kubernetes-Cluster ausführen können. Mit Ilum ist das Bereitstellen, Verwalten und Skalieren von Apache Spark-Clustern einfach und natürlich möglich.

Einleitung

Heute zeigen wir, wie Sie Apache Spark auf K8s in Betrieb nehmen können. Es gibt viele Möglichkeiten, dies zu tun, aber die meisten sind komplex und erfordern mehrere Konfigurationen. Wir werden Ilum Da dies die gesamte Cluster-Einrichtung für uns erledigt. Im nächsten Blogbeitrag werden wir die Nutzung mit dem Spark-Operator vergleichen.

Ilum ist ein kostenloses, modulares Data Lakehouse zur einfachen Bereitstellung und Verwaltung von Apache Spark Clustern. Es verfügt über eine einfache API zum Definieren und Verwalten von Spark, die alle Abhängigkeiten verarbeitet. Es hilft bei der Erstellung Ihres eigenen verwalteten Funkens.

Mit Ilum können Sie Spark-Cluster in wenigen Minuten bereitstellen und sofort mit dem Ausführen von Spark-Anwendungen beginnen. Ilum ermöglicht Ihnen das einfache Skalieren nach draußen und in Ihren Spark-Clustern, indem Sie mehrere Spark-Cluster von einer einzigen Benutzeroberfläche aus verwalten.

Mit Ilum ist der Einstieg einfach, wenn Sie noch relativ neu in Apache Spark auf Kubernetes sind.

Schritt-für-Schritt-Anleitung zur Installation von Apache Spark auf Kubernetes

Schnellstart

Wir gehen davon aus, dass Sie einen Kubernetes-Cluster eingerichtet und ausgeführt haben, nur für den Fall, dass dies nicht der Fall ist, sehen Sie sich diese Anleitung zum Einrichten eines Kubernetes-Clusters auf dem Minikube an. Überprüfen Sie, wie Sie minikube installieren .

Einrichten eines lokalen Kubernetes-Clusters

Minikube installieren: Führen Sie den folgenden Befehl aus, um Minikube zusammen mit den empfohlenen Ressourcen zu installieren. Dadurch wird Minikube mit 6 vCPUs und 12288 MB Arbeitsspeicher installiert, einschließlich des für das Monitoring erforderlichen Metrics-Server-Add-ons.

minikube start --cpus 6 --memory 12288 --addons metrics-server

Sobald Sie einen laufenden Kubernetes-Cluster haben, sind es nur noch wenige Befehle, um Ilum zu installieren:

Spark auf Kubernetes mit Ilum installieren

Hinzufügen Ilum Helm Repository

helm repo add ilum https://charts.ilum.cloud

Installieren Sie ilum in Ihrem Cluster

Helm install und ile/el

💡

Eine langsame Internetgeschwindigkeit und eine große Docker-Image-Größe können aufgrund der 2-minütigen Download-Zeitüberschreitung zum Ausfall des Kubernetes-Pods führen. Aus diesem Grund empfehlen wir, das Image manuell zu ziehen, ohne eine Zeitüberschreitung zu erhalten.

minikube ssh docker pull ilum/core:6.2.0

Diese Einrichtung sollte etwa zwei Minuten dauern. Ilum wird in Ihrem Kubernetes-Cluster bereitgestellt und bereitet ihn für die Verarbeitung von Spark-Aufträgen vor.

Sobald Ilum installiert ist, können Sie mit port-forward und localhost:9777 auf die Benutzeroberfläche zugreifen.

Portweiterleitung zur Access-Benutzeroberfläche: Verwenden Sie die Kubernetes-Portweiterleitung, um auf die Ilum-Benutzeroberfläche zuzugreifen.

kubectl port-forward svc/ilum-ui 9777:9777

Gebrauchen admin/admin als Standardanmeldeinformationen. Sie können sie während der Bereitstellungsprozess .

Das ist alles, Ihr Kubernetes-Cluster ist jetzt für die Verarbeitung von Spark-Jobs konfiguriert. Ilum bietet eine einfache API und Benutzeroberfläche, die das Übermitteln von Spark-Anwendungen erleichtert. Sie können auch das gute alte spark senden .

Bereitstellen einer Spark-Anwendung auf Kubernetes

Beginnen wir nun mit einem einfachen Spark-Job. Wir verwenden das "SparkPi"-Beispiel aus dem Spark Dokumentation . Sie können die JAR-Datei aus diesem verbinden .

ilum Spark-Job hinzufügen

Ilum erstellt einen Kubernetes-Pod für den Spark-Treiber, der das Docker-Image der Spark-Version 3.x verwendet. Sie können die Anzahl der Spark-Executor-Pods steuern, indem Sie sie auf mehrere Knoten skalieren. Das ist der einfachste Weg, um Spark-Bewerbungen bei K8s einzureichen.

Das Ausführen von Spark auf Kubernetes ist mit Ilum wirklich einfach und reibungslos. Es konfiguriert Ihren gesamten Cluster und stellt Ihnen eine Schnittstelle zur Verfügung, über die Sie Ihren Spark-Cluster verwalten und überwachen können. Wir glauben, dass Spark-Apps auf Kubernetes die Zukunft von Big Data sind. Mit Kubernetes werden Spark-Anwendungen in der Lage sein, große Datenmengen viel zuverlässiger zu verarbeiten, so dass sie genaue Einblicke geben und Entscheidungen mit Big Data treffen können.

Übermitteln einer Spark-Anwendung an Kubernetes (alter Stil)

Das Übermitteln eines Spark-Auftrags an einen Kubernetes-Cluster umfasst die Verwendung der spark-submit Skript mit Kubernetes-spezifischen Konfigurationen. Hier ist eine Schritt-für-Schritt-Anleitung:

Schritte :

Vorbereiten der Spark-Anwendung : Packen Sie Ihre Spark-Anwendung in eine JAR-Datei (für Scala/Java) oder ein Python-Skript.
Gebrauchen spark-submit zum Bereitstellen : Führen Sie die Funktion spark-submit mit Kubernetes-spezifischen Optionen:
```
./bin/spark-submit \
  --master k8s://https://<k8s-apiserver-host>:<k8s-apiserver-port> \
  --deploy-mode cluster \
  --name spark-app \
  --class org.apache.spark.examples.SparkPi \
  --conf spark.executor.instances=3 \
  --conf spark.kubernetes.container.image=<your-spark-image> \
  local:///path/to/your-app.jar 
```
Ersetzen:
- <k8s-apiserver-host> : Ihr Kubernetes-API-Server-Host.
- <k8s-apiserver-port> : Ihr Kubernetes-API-Serverport.
- <your-spark-image> : Das Docker-Image, das Spark enthält.
- local:///path/to/your-app.jar : Pfad zu Ihrer Anwendungs-JAR innerhalb des Docker-Images.

Wichtige Konfigurationen :

--Meister : Gibt die Kubernetes-API-URL an.
--deploy-modus : Setzen Sie auf Cluster , um den Treiber innerhalb des Kubernetes-Clusters auszuführen.
--Name : Benennt Ihre Spark-Anwendung.
--Klasse : Hauptklasse Ihrer Anwendung.
--conf spark.executor.instances : Anzahl der Executor-Pods.
--conf spark.kubernetes.container.image : Docker-Image für Spark-Pods.

Weitere Informationen finden Sie in der Apache Spark-Dokumentation zur Ausführung in Kubernetes .

2. Erstellen eines benutzerdefinierten Docker-Images für Spark

Das Erstellen eines benutzerdefinierten Docker-Images ermöglicht es Ihnen, Ihre Spark-Anwendung und ihre Abhängigkeiten zu packen und so die Konsistenz in allen Umgebungen sicherzustellen.

Schritte :

Erstellen einer Dockerfile : Definieren Sie die Umgebung und die Abhängigkeiten.

# Verwenden Sie das offizielle Spark-Basisimage
VON funken:3.5.3

# Umgebungsvariablen setzen
ENV SPARK_HOME=/opt/funken
ENV PFAD=$PATH:$SPARK_HOME/BIN

# Kopieren Sie Ihre Anwendungs-JAR in das Image
COPY your-app.jar $SPARK_HOME/Beispiele/Gläser/

# Festlegen des Einstiegspunkts zum Ausführen Ihrer Anwendung
ENTRYPOINT ["spark-submit", "--class", "org.apache.spark.examples.SparkPi", "--master", "local[4]", "/opt/spark/examples/jars/your-app.jar"]

In diesem Dockerfile:

VON funken:3.5.3 : Verwendet das offizielle Spark-Image als Basis.
ENV : Legt Umgebungsvariablen für Spark fest.
KOPIEREN : Fügt dem Image Ihre Anwendungs-JAR hinzu.
EINSTIEG : Definiert den Standardbefehl zum Ausführen Ihrer Spark-Anwendung.

Erstellen des Docker-Images : Verwenden Sie Docker, um Ihr Image zu erstellen.
```
docker build -t your-repo/your-spark-app:latest . 
```
Ersetzen Ihr-Repository/Ihre-Funken-App mit Ihrem Docker-Repository und dem Image-Namen.
Pushen des Images in eine Registrierung : Laden Sie Ihr Image in eine Docker-Registrierung hoch, auf die Ihr Kubernetes-Cluster zugreifen kann.
```
docker push your-repo/your-spark-app:latest 
```

Während der Verwendung spark-submit ist eine gängige Methode zum Bereitstellen von Spark-Anwendungen, ist jedoch möglicherweise nicht der effizienteste Ansatz für Produktionsumgebungen. Manuelle Einreichungen können zu Inkonsistenzen führen und lassen sich nur schwer in automatisierte Arbeitsabläufe integrieren. Um die Effizienz und Wartbarkeit zu verbessern, wird die Nutzung der REST-API von Ilum empfohlen.

Automatisieren von Spark-Bereitstellungen mit der REST-API von Ilum

Ilum bietet eine robuste RESTful API, die eine nahtlose Interaktion mit Spark-Clustern ermöglicht. Diese API erleichtert die Automatisierung von Auftragsübermittlungen, -überwachung und -verwaltung und ist damit die ideale Wahl für CI/CD-Pipelines (Continuous Integration/Continuous Deployment).

Vorteile der Verwendung der REST-API von Ilum:

Automatisierung : Integrieren Sie Spark-Auftragsübermittlungen in CI/CD-Pipelines, um manuelle Eingriffe und potenzielle Fehler zu reduzieren.
Konsistenz : Stellen Sie einheitliche Bereitstellungsprozesse in verschiedenen Umgebungen sicher.
Skalierbarkeit : Verwalten Sie mehrere Spark-Cluster und -Aufträge einfach programmgesteuert.

Beispiel: Übermitteln eines Spark-Jobs über die REST-API von ilum

Um einen Spark-Auftrag über die REST-API von Ilum zu übermitteln, können Sie eine HTTP POST-Anfrage mit den erforderlichen Parametern stellen. Hier ist ein vereinfachtes Beispiel mit Locke :

curl -X POST https://<ilum-server>/api/v1/job/submit \
  -H "Inhaltstyp: multipart/formular-daten" \
  -F "name=Beispiel-Auftrag" \
  -F "clusterName=Standard" \
  -F "jobClass=org.apache.spark.examples.SparkPi" \
  -F "jars=@/Pfad/zum/your-app.jar" \
  -F "jobConfig=spark.executor.instances=3; spark.executor.memory=4g"

In diesem Befehl:

Name : Gibt den Namen des Auftrags an.
clusterName : Gibt den Zielcluster an.
jobKlasse : Definiert die Hauptklasse Ihrer Spark-Anwendung.
Krüge : Lädt die JAR-Datei Ihrer Anwendung hoch.
jobConfig : Legt Spark-Konfigurationen fest, z. B. die Anzahl der Executors und die Speicherbelegung.

Ausführliche Informationen zu den API-Endpunkten und -Parametern finden Sie in der Ilum API Dokumentation .

Effizienzsteigerung mit interaktiven Spark-Jobs

Neben der Automatisierung von Auftragsübermittlungen kann die Umwandlung von Spark-Aufträgen in interaktive Microservices die Ressourcenauslastung und die Reaktionszeiten erheblich optimieren. Ilum unterstützt die Erstellung von interaktiven Spark-Sitzungen mit langer Laufzeit, die Echtzeitdaten verarbeiten können, ohne dass für jede Anforderung ein neuer Spark-Kontext initialisiert werden muss.

Vorteile von Interactive Spark Jobs:

Reduzierte Latenz : Eliminiert die Notwendigkeit, für jeden Auftrag einen neuen Spark-Kontext zu starten, was zu einer schnelleren Ausführung führt.
Ressourcen-Optimierung : Behält einen persistenten Spark-Kontext bei, der eine effiziente Ressourcenverwaltung ermöglicht.
Skalierbarkeit : Verarbeitet mehrere Anforderungen gleichzeitig innerhalb derselben Spark-Sitzung.

Um einen interaktiven Spark-Job mit Ilum zu implementieren, können Sie eine Spark-Anwendung definieren, die auf eingehende Daten lauscht und diese in Echtzeit verarbeitet. Dieser Ansatz ist besonders vorteilhaft für Anwendungen, die eine sofortige Datenverarbeitung und -reaktion erfordern.

Eine umfassende Anleitung zum Einrichten interaktiver Spark-Aufträge und zum Optimieren Ihres Spark-Clusters finden Sie im Blogbeitrag von Ilum: Optimieren Ihres Spark-Clusters mit interaktiven Spark-Aufträgen .

Durch die Integration der REST-API von Ilum und die Einführung interaktiver Spark-Jobs können Sie Ihre Spark-Workflows optimieren, die Automatisierung verbessern und eine effizientere und skalierbarere Datenverarbeitungsumgebung erreichen.

Vorteile der Verwendung von Ilum zum Ausführen von Spark auf Kubernetes

Ilum ist mit einer intuitiven Benutzeroberfläche und einer ausfallsicheren API ausgestattet, um Spark-Cluster zu skalieren und zu handhaben und einige Spark-Anwendungen über eine Schnittstelle zu konfigurieren. Hier sind ein paar großartige Funktionen in dieser Hinsicht:

Benutzerfreundlichkeit : Ilum vereinfacht die Spark-Konfiguration und -Verwaltung auf Kubernetes mit einer intuitiven Spark-Benutzeroberfläche, wodurch komplexe Einrichtungsprozesse überflüssig werden.
Schnelle Bereitstellung: Einrichten, Bereitstellen und Skalieren von Spark-Clustern in wenigen Minuten, um die Zeit bis zur sofortigen Ausführung und zum Testen von Anwendungen zu verkürzen.
Skalierbarkeit: Mit der Kubernetes-API können Sie Spark-Cluster einfach nach oben oder unten skalieren, um Ihre Anforderungen an die Datenverarbeitung zu erfüllen und eine optimale Ressourcenauslastung zu gewährleisten.
Modularität : Ilum wird mit einem modularen Framework ausgeliefert, das es den Nutzern ermöglicht, verschiedene Komponenten wie Spark History Server, Apache Jupyter, Minio und vieles mehr auszuwählen und zu kombinieren.

Migrieren von Apache Hadoop Yarn

Jetzt, da Apache Hadoop Yarn in einer tiefen Stagnation steckt, erwägen immer mehr Unternehmen eine Migration von Yarn zu Kubernetes. Dies wird auf mehrere Gründe zurückgeführt, aber der häufigste ist, dass Kubernetes eine widerstandsfähigere und flexiblere Plattform für die Verwaltung von Big-Data-Workloads bietet.

Im Allgemeinen ist es schwierig, eine Plattformmigration der Datenverarbeitungsplattform von Apache Hadoop Yarn auf eine andere durchzuführen. Bei einem solchen Wechsel sind viele Faktoren zu berücksichtigen: Kompatibilität der Daten, Geschwindigkeit und Verarbeitungskosten. Es würde jedoch reibungslos und erfolgreich verlaufen, wenn das Verfahren gut geplant und durchgeführt wird.

Kubernetes ist aufgrund seiner inhärenten Fähigkeit, horizontal skalieren zu können, eine natürliche Lösung, wenn es um Big-Data-Workloads geht. Mit Hadoop Yarn sind Sie jedoch auf die Anzahl der Knoten in Ihrem Cluster beschränkt. Sie können die Anzahl der Knoten in einem Kubernetes-Cluster bei Bedarf erhöhen und reduzieren.

Es ermöglicht auch Funktionen, die in Yarn nicht verfügbar sind, z. B. Selbstheilung und horizontale Skalierung.

Zeit für den Umstieg auf Kubernetes?

Mit der Weiterentwicklung der Welt von Big Data entwickeln sich auch die Tools und Technologien, die zu ihrer Verwaltung eingesetzt werden. Seit Jahren ist Apache Hadoop YARN der De-facto-Standard für das Ressourcenmanagement in Big-Data-Umgebungen. Aber ist es mit dem Aufkommen von Containerisierungs- und Orchestrierungstechnologien wie Kubernetes an der Zeit, umzusteigen?

Kubernetes hat als Container-Orchestrierungsplattform immer mehr an Popularität gewonnen, und das aus gutem Grund. Es ist flexibel, skalierbar und relativ einfach zu bedienen. Wenn Sie immer noch eine herkömmliche VM-basierte Infrastruktur verwenden, ist jetzt möglicherweise der richtige Zeitpunkt, um auf Kubernetes umzusteigen.

Wenn Sie mit Containern arbeiten, dann sollten Sie sich auf jeden Fall für Kubernetes interessieren. Es kann Ihnen helfen, Ihre Container effektiver zu verwalten und bereitzustellen, und es ist besonders nützlich, wenn Sie mit vielen Containern arbeiten oder wenn Sie Ihre Container auf einer Cloud-Plattform bereitstellen.

Kubernetes ist auch eine gute Wahl, wenn Sie nach einem Orchestrierungstool suchen, das von einem großen Technologieunternehmen unterstützt wird. Google verwendet Kubernetes seit Jahren, um seine eigenen containerisierten Anwendungen zu verwalten, und sie haben viel Zeit und Ressourcen investiert, um es zu einem großartigen Tool zu machen.

In der Debatte YARN vs. Kubernetes gibt es keinen klaren Gewinner. Die beste Lösung für Ihr Unternehmen hängt von Ihren spezifischen Anforderungen und Anwendungsfällen ab. Wenn Sie auf der Suche nach einer flexibleren und skalierbareren Lösung für das Ressourcenmanagement sind, ist Kubernetes eine Überlegung wert. Wenn Sie eine bessere Unterstützung für Legacy-Anwendungen benötigen, ist YARN möglicherweise die bessere Option.

Für welche Plattform Sie sich auch entscheiden, Ilum kann Ihnen helfen, das Beste daraus zu machen. Unsere Plattform ist so konzipiert, dass sie sowohl mit YARN als auch mit Kubernetes funktioniert, und unser Expertenteam kann Ihnen helfen, die richtige Lösung für Ihr Unternehmen auszuwählen und zu implementieren.

Verwalteter Spark-Cluster

Ein verwalteter Spark-Cluster ist eine cloudbasierte Lösung, die das Bereitstellen und Verwalten von Spark-Clustern vereinfacht. Es bietet eine webbasierte Schnittstelle zum Erstellen und Verwalten von Spark-Clustern sowie eine Reihe von APIs zum Automatisieren von Clusterverwaltungsaufgaben. Verwaltete Spark-Cluster werden häufig von Data Scientists und Entwicklern verwendet, die Spark-Cluster schnell bereitstellen und verwalten möchten, ohne sich um die zugrunde liegende Infrastruktur kümmern zu müssen.

Ilum bietet die Möglichkeit, einen eigenen Spark-Cluster zu erstellen und zu verwalten, der in jeder Umgebung ausgeführt werden kann, einschließlich Cloud, On-Premises oder einer Mischung aus beidem.

Die Vorteile von Apache Spark auf Kubernetes

Es gab einige Debatten darüber, ob Apache Spark auf Kubernetes laufen sollte.

Einige Leute argumentieren, dass Kubernetes zu komplex ist und dass Spark weiterhin auf einem eigenen dedizierten Cluster-Manager laufen oder in der Cloud bleiben sollte. Andere argumentieren, dass Kubernetes die Zukunft der Big-Data-Verarbeitung ist und dass Spark sie annehmen sollte.

Wir befinden uns im letzteren Lager. Wir glauben, dass Kubernetes die Zukunft der Big-Data-Verarbeitung ist und dass Apache Spark auf Kubernetes laufen sollte.

Der größte Vorteil der Verwendung von Spark in Kubernetes besteht darin, dass es eine viel einfachere Skalierung von Spark-Anwendungen ermöglicht. Dies liegt daran, dass Kubernetes für die Bereitstellung einer großen Anzahl gleichzeitiger Container ausgelegt ist. Wenn Sie also über eine Spark-Anwendung verfügen, die viele Daten verarbeiten muss, können Sie einfach mehr Container im Kubernetes-Cluster bereitstellen, um die Daten parallel zu verarbeiten. Dies ist viel einfacher, als jedes Mal einen neuen Spark-Cluster auf EMR einzurichten, wenn Sie Ihre Verarbeitung hochskalieren müssen. Sie können es auf jeder Cloud-Plattform (AWS, Google Cloud, Azure usw.) oder vor Ort ausführen. Das bedeutet, dass Sie Ihre Spark-Anwendungen problemlos von einer Umgebung in eine andere verschieben können, ohne sich um einen Wechsel des Cluster-Managers kümmern zu müssen.

Ein weiterer enormer Vorteil ist, dass es flexiblere Arbeitsabläufe ermöglicht. Wenn Sie z. B. Daten aus mehreren Quellen verarbeiten müssen, können Sie problemlos unterschiedliche Container für jede Quelle bereitstellen und alle parallel verarbeiten lassen. Dies ist viel einfacher als der Versuch, einen komplexen Workflow in einem einzelnen Spark-Cluster zu verwalten.

Kubernetes verfügt über mehrere Sicherheitsfunktionen, die es zu einer attraktiveren Option für die Ausführung von Spark-Anwendungen machen. Kubernetes unterstützt beispielsweise die rollenbasierte Zugriffssteuerung, mit der Sie fein abstimmen können, wer Zugriff auf Ihren Spark-Cluster hat.

Da haben Sie es also. Dies sind nur einige der Gründe, warum wir glauben, dass Apache Spark auf Kubernetes laufen sollte. Wenn Sie nicht überzeugt sind, empfehlen wir Ihnen, es selbst auszuprobieren. Wir glauben, Sie werden überrascht sein, wie gut es funktioniert.

Zusätzliche Ressourcen

Schlussfolgerung

Ilum vereinfacht den Prozess der Installation und Verwaltung von Apache Spark auf Kubernetes und ist damit sowohl für Anfänger als auch für erfahrene Benutzer die ideale Wahl. Wenn Sie dieser Anleitung folgen, haben Sie im Handumdrehen einen funktionsfähigen Spark-Cluster, der auf Kubernetes ausgeführt wird.

Probieren Sie es aus, es ist kostenlos