Bereitstellen von PySpark Microservices auf Kubernetes: Revolutionierung von Data Lakes mit Ilum.
Seid gegrüßt, Ilum-Enthusiasten und Python-Fans! Wir freuen uns, Ihnen eine neue, mit Spannung erwartete Funktion vorstellen zu können, die Ihre Data-Science-Reise erleichtern wird - die vollständige Python-Unterstützung in Ilum. Für diejenigen, die in der Datenwelt tätig sind, sind Python und Apache Spark seit langem ein ikonisches Duo, das riesige Datenmengen und komplexe Berechnungen nahtlos verarbeitet. Und jetzt, mit dem neuesten Upgrade von Ilum, können Sie die Leistungsfähigkeit von Python direkt in Ihrer bevorzugten Data-Lake-Umgebung nutzen.
Dieser Blogbeitrag ist Ihre geführte Tour zur Erkundung dieser Funktion. Wir beginnen mit einem einfachen Apache Spark-Auftrag, der in Python geschrieben wurde, führen ihn auf Ilum aus und tauchen dann tiefer ein. Wir transformieren den anfänglichen Code so, dass er einen interaktiven Modus unterstützt, der Ihnen über die API von Ilum direkten Zugriff auf den Spark-Auftrag bietet. Am Ende dieser Reise haben Sie einen Python-basierten Microservice, der auf API-Aufrufe reagiert und alle reibungslos auf Ilum laufen.
Sind Sie bereit, Ihr Datenspiel mit Python und Ilum zu verbessern? Fangen wir an.
Alle Beispiele finden Sie auf unserer GitHub-Repository .
Schritt 1: Schreiben eines einfachen Apache Spark-Jobs in Python.
Bevor wir unsere Python-Reise mit Ilum beginnen, müssen wir sicherstellen, dass unsere Umgebung gut ausgestattet ist. Zum Ausführen eines Spark-Auftrags müssen Ilum und PySpark installiert sein. Sie können pip, das Python-Paketinstallationsprogramm, verwenden, um PySpark einzurichten. Stellen Sie sicher, dass Sie Python >=3.9 verwenden.
pip install pyspark Für die Einrichtung und den Zugriff auf Ilum befolgen Sie bitte die bereitgestellten Richtlinien hier .
1.1 Beispiel für SparkPi.
Lassen Sie uns nun in das Schreiben unseres Spark-Jobs eintauchen. Wir beginnen mit einem einfachen Beispiel für SparkPi
SYS importieren
aus zufälligem Import zufällig
Aus Operatorimport hinzufügen
aus pyspark.sql SparkSession importieren
if __name__ == "__main__":
Funke = SparkSession \
.Bauherr\
.appName("PythonPi") \
.getOrCreate()
partitions = int(sys.argv[1]) if len(sys.argv) > 1 else 2
n = 100000 * Partitionen
def f(_: int) -> Gleitkomma:
x = zufällig() * 2 - 1
y = zufällig() * 2 - 1
return 1 if x ** 2 + y ** 2 <= 1 else 0
count = spark.sparkContext.parallelize(range(1, n + 1), Partitionen).map(f).reduce(hinzufügen)
print("Pi ist ungefähr %f" % (4.0 * count / n))
spark.stop() Speichern Sie dieses Skript unter ilum_python_simple.py
Nachdem unser Spark-Job fertig ist, ist es an der Zeit, ihn auf Ilum auszuführen. Ilum bietet die Möglichkeit, Aufträge über die Ilum-Benutzeroberfläche oder über die REST-API zu übermitteln.
Beginnen wir mit der Benutzeroberfläche mit dem Einzeljob-Funktion.
Das Gleiche können wir mit der API , aber zuerst müssen wir die ilum-core-API mit Portweiterleitung verfügbar machen.
kubectl port-forward svc/ilum-core 9888:9888 Mit dem exponierten Port können wir einen API-Aufruf durchführen.
curl -X POST 'localhost:9888/api/v1/job/submit' \
--form 'name="ilumSimplePythonJob"' \
--form 'clusterName="Standard"' \
--form 'jobClass="ilum_python_simple"' \
--form 'args="10"' \
--form 'pyFiles=@"/Pfad/zum/ilum_python_simple.py"' \
--form 'Sprache="PYTHON"' API-Aufruf
Als Ergebnis erhalten wir die ID des erstellten Auftrags.
{"jobId":"20230724-1154-m78f3gmlo5j"} Ergebnis
Um die Protokolle des Jobs zu überprüfen, können wir einen API-Aufruf an
curl localhost:9888/api/v1/job/20230724-1154-m78f3gmlo5j/logs API-Aufruf
Und das ist es! Sie haben einen einfachen Python Spark-Job auf Ilum geschrieben und führen ihn aus. Schauen wir uns ein etwas fortgeschritteneres Beispiel an, das zusätzliche Python-Bibliotheken benötigt.
1.2 Jobbeispiel mit numpy.
In diesem Abschnitt gehen wir auf ein praktisches Beispiel eines in Python geschriebenen Spark-Auftrags ein. Diese Aufgabe umfasst das Lesen eines Datasets, das Verarbeiten, das Trainieren eines Machine Learning-Modells und das Speichern der Vorhersagen. Wir werden eine verwenden Tel-churn.csv Datei, die Sie in unserer GitHub-Repository . Um die Dinge zu vereinfachen, haben wir diese Datei in einen Bucket mit dem Namen ilum-files in der Build-In-Instanz von MinIO hochgeladen, auf die automatisch von der Ilum-Instanz aus zugegriffen werden kann. Das bedeutet, dass Sie sich keine Gedanken über die Konfiguration von Zugängen für dieses Beispiel machen müssen - Ilum hat es abgedeckt. Wenn Sie jedoch jemals Daten aus einem anderen Bucket abrufen oder Amazon S3 in Ihren eigenen Projekten verwenden möchten, müssen Sie die Zugriffe entsprechend konfigurieren.
Nachdem wir nun unsere Daten fertig haben, beginnen wir mit dem Schreiben unseres Spark-Auftrags in Python. Hier ist das vollständige Codebeispiel:
aus pyspark.sql SparkSession importieren
aus pyspark.ml importieren Pipeline
von pyspark.ml.feature import StringIndexer, VectorAssembler
von pyspark.ml.classification import LogisticRegression
if __name__ == "__main__":
Funke = SparkSession \
.Bauherr\
.appName("IlumAdvancedPythonExample") \
.getOrCreate()
df = spark.read.csv('s3a://ilum-files/Tel-churn.csv', header=Wahr, inferSchema=Wahr)
categoricalColumns = ['Geschlecht', 'Partner', 'Angehörige', 'PhoneService', 'MultipleLines', 'InternetService',
'OnlineSecurity', 'OnlineBackup', 'DeviceProtection', 'TechSupport', 'StreamingTV',
'StreamingMovies', 'Vertrag', 'Papierlose Abrechnung', 'Zahlungsmethode']
Stufen = []
für categoricalCol in categoricalColumns:
stringIndexer = StringIndexer(inputCol=kategorischCol, outputCol=kategorischCol + "Index")
stufen += [stringIndexer]
label_stringIdx = StringIndexer(inputCol="Abwanderung", outputCol="Beschriftung")
Phasen += [label_stringIdx]
numericCols = ['SeniorCitizen', 'Amtszeit', 'Monatliche Gebühren']
assemblerInputs = [c + "Index" für c in categoricalColumns] + numericCols
assembler = VectorAssembler(inputCols=assemblerInputs, outputCol="Funktionen")
Stufen += [Monteur]
pipeline = Pipeline(stages=stages)
pipelineModell = pipeline.fit(df)
df = pipelineModel.transform(df)
trainieren, test = df.randomSplit([0.7; 0.3], seed=42)
lr = Logistische Regression(featuresCol="Merkmale", labelCol="Beschriftung", maxIter=10)
lrModel = lr.fit(Zug)
Vorhersagen = lrModel.transform(test)
predictions.select("customerID", "label", "prediction").show(5)
predictions.select("customerID", "label", "prediction").write.option("header", "true") \
.csv('s3a://ilum-files/predictions')
spark.stop() Lassen Sie uns in den Code eintauchen:
aus pyspark.sql SparkSession importieren
aus pyspark.ml importieren Pipeline
von pyspark.ml.feature import StringIndexer, VectorAssembler
von pyspark.ml.classification import LogisticRegression Hier importieren wir die erforderlichen PySpark-Module, um eine Spark-Sitzung zu erstellen, eine Machine Learning-Pipeline zu erstellen, die Daten vorzuverarbeiten und ein logistisches Regressionsmodell auszuführen.
Funke = SparkSession \
.Bauherr\
.appName("IlumAdvancedPythonExample") \
.getOrCreate() Wir initialisieren eine SparkSession (Englisch) , der den Einstiegspunkt zu allen Funktionen in Spark darstellt. Hier legen wir den Anwendungsnamen fest, der auf der Spark-Webbenutzeroberfläche angezeigt wird.
df = spark.read.csv('s3a://ilum-files/Tel-churn.csv', header=Wahr, inferSchema=Wahr) Wir lesen eine CSV-Datei, die in einem Minio-Bucket gespeichert ist. Das header=Wahr Option weist Spark an, die erste Zeile der CSV-Datei als Header zu verwenden, während inferSchema=Wahr sorgt dafür, dass Spark automatisch den Datentyp jeder Spalte bestimmt.
categoricalColumns = ['Geschlecht', 'Partner', 'Angehörige', 'PhoneService', 'MultipleLines', 'InternetService',
'OnlineSecurity', 'OnlineBackup', 'DeviceProtection', 'TechSupport', 'StreamingTV',
'StreamingMovies', 'Vertrag', 'Papierlose Abrechnung', 'Zahlungsmethode'] Wir geben die Spalten in unseren Daten an, die kategorisch sind. Diese werden später mit einem StringIndexer transformiert.
Stufen = []
für categoricalCol in categoricalColumns:
stringIndexer = StringIndexer(inputCol=kategorischCol, outputCol=kategorischCol + "Index")
stufen += [stringIndexer] Hier durchlaufen wir unsere Liste der kategorischen Spalten und erstellen für jede Spalte einen StringIndexer. StringIndexers codieren kategoriale Zeichenfolgenspalten in eine Spalte mit Indizes. Die transformierte Indexspalte wird als ursprünglicher Spaltenname benannt und mit dem Zusatz "Index" versehen.
numericCols = ['SeniorCitizen', 'Amtszeit', 'Monatliche Gebühren']
assemblerInputs = [c + "Index" für c in categoricalColumns] + numericCols
assembler = VectorAssembler(inputCols=assemblerInputs, outputCol="Funktionen")
Stufen += [Monteur] Hier bereiten wir die Daten für unser Machine-Learning-Modell vor. Wir erstellen einen VectorAssembler, der alle unsere Feature-Spalten (sowohl kategoriale als auch numerische) zu einer einzigen Vektorspalte zusammenfügt. Dies ist eine Voraussetzung für die meisten Machine Learning-Algorithmen in Spark.
trainieren, test = df.randomSplit([0.7; 0.3], seed=42) Wir teilen unsere Daten in einen Trainingssatz und einen Testsatz auf, wobei 70 % der Daten für das Training und die restlichen 30 % für Tests bestimmt sind.
lr = Logistische Regression(featuresCol="Merkmale", labelCol="Beschriftung", maxIter=10)
lrModel = lr.fit(Zug) Wir trainieren ein logistisches Regressionsmodell mit unseren Trainingsdaten.
Vorhersagen = lrModel.transform(test)
predictions.select("customerID", "label", "prediction").show(5)
predictions.select("customerID", "label", "prediction").write.option("header", "true") \
.csv('s3a://ilum-files/predictions') Zuletzt verwenden wir unser trainiertes Modell, um Vorhersagen auf unserem Testsatz zu treffen und die ersten 5 Vorhersagen anzuzeigen. Dann schreiben wir diese Vorhersagen zurück in unseren Minio-Eimer.
Speichern Sie dieses Skript unter ilum_python_advanced.py
pyspark.ml verwendet numpy als Abhängigkeit, die nicht standardmäßig installiert ist, daher müssen wir sie als Anforderung angeben.
Und das Gleiche kann über die API getan werden.
curl -X POST 'localhost:9888/api/v1/job/submit' \
--form 'name="IlumAdvancedPythonExample"' \
--form 'clusterName="Standard"' \
--form 'jobClass="ilum_python_advanced"' \
--form 'pyRequirements="numpy"' \
--form 'pyFiles=@"/Pfad/zum/ilum_python_advanced.py"' \
--form 'Sprache="PYTHON"' API-Aufruf
In den nächsten Abschnitten transformieren wir beide Python-Skripte in ein interaktiv Zünden Sie den Job an und nutzen Sie die Möglichkeiten von Ilum voll aus.
Schritt 2: Übergang in den interaktiven Modus
Der interaktive Modus ist ein spannendes Feature, das die Spark-Entwicklung dynamischer macht und Ihnen die Möglichkeit gibt, Ihre Spark-Aufträge in Echtzeit auszuführen, zu interagieren und zu steuern. Es wurde für diejenigen entwickelt, die eine direktere Kontrolle über ihre Spark-Anwendungen wünschen.
Stellen Sie sich den interaktiven Modus so vor, als hätten Sie eine direkte Konversation mit Ihrem Spark-Auftrag. Sie können Daten einspeisen, Transformationen anfordern und Ergebnisse abrufen - alles in Echtzeit. Dies verbessert die Agilität und Leistungsfähigkeit Ihrer Datenverarbeitungspipeline drastisch und macht sie anpassungsfähiger und reaktionsfähiger an sich ändernde Anforderungen.
Nachdem wir nun mit der Erstellung eines einfachen Spark-Auftrags in Python vertraut sind, gehen wir noch einen Schritt weiter, indem wir unseren Auftrag in einen interaktiven Auftrag umwandeln, der die Echtzeitfunktionen von Ilum nutzen kann.
2.1 Beispiel für SparkPi.
Um zu veranschaulichen, wie wir unseren Job in den interaktiven Modus überführen, werden wir unsere früheren ilum_python_simple.py Skript.
aus zufälligem Import zufällig
Aus Operatorimport hinzufügen
von ilum.api import IlumJob
Klasse SparkPiInteractiveExample(IlumJob):
def run(self, spark, config):
partitions = int(config.get('Partitionen', '5'))
n = 100000 * Partitionen
def f(_: int) -> Gleitkomma:
x = zufällig() * 2 - 1
y = zufällig() * 2 - 1
return 1 if x ** 2 + y ** 2 <= 1 else 0
count = spark.sparkContext.parallelize(range(1, n + 1), Partitionen).map(f).reduce(hinzufügen)
return "Pi ist ungefähr %f" % (4.0 * count / n) Speichern Sie dies unter ilum_python_simple_interactive.py
Es gibt nur ein paar Unterschiede zum originalen SparkPi.
1. Ilum-Paket
Zu Beginn importieren wir die IlumJob class aus dem ilum-Paket, das als Basisklasse für unseren interaktiven Job dient.
Die Spark-Auftragslogik ist in einer Klasse gekapselt, die IlumJob , insbesondere im Rahmen seiner laufen Methode. Wir können das ilum-Paket hinzufügen mit:
pip install ilum 2. Spark-Auftrag in einer Klasse
Die Spark-Auftragslogik ist in einer Klasse gekapselt, die IlumJob , insbesondere im Rahmen seiner laufen Methode.
Klasse SparkPiInteractiveExample(IlumJob):
def run(self, spark, config):
# Joblogik hier Das Einpacken der Joblogik in eine Klasse ist für das Ilum-Framework unerlässlich, um den Job und seine Ressourcen zu verarbeiten. Dadurch wird der Job auch zustandslos und wiederverwendbar.
3. Parameter werden unterschiedlich gehandhabt:
Wir nehmen alle Argumente aus dem config-Wörterbuch
partitions = int(config.get('Partitionen', '5')) Diese Verschiebung ermöglicht eine dynamischere Parameterübergabe und lässt sich in die Konfigurationshandhabung von Ilum integrieren.
4. Das Ergebnis wird zurückgegeben und nicht gedruckt:
Das Ergebnis wird von der laufen Methode.
return "Pi ist ungefähr %f" % (4.0 * count / n) Durch die Rückgabe des Ergebnisses kann Ilum flexibler damit umgehen. So könnte Ilum beispielsweise das Ergebnis serialisieren und über einen API-Aufruf zugänglich machen.
5. Es ist nicht erforderlich, die Spark-Sitzung manuell zu verwalten
Ilum managt die Spark-Session für uns. Es wird automatisch in die laufen -Methode und wir müssen sie nicht manuell stoppen.
def run(self, spark, config): Diese Änderungen verdeutlichen den Übergang von einem eigenständigen Spark-Auftrag zu einem interaktiven Ilum-Auftrag. Ziel ist es, die Flexibilität und Wiederverwendbarkeit des Auftrags zu verbessern, sodass er sich besser für dynamische, interaktive und spontane Berechnungen eignet.
Das Hinzufügen eines interaktiven Spark-Jobs wird mit der Funktion "Neue Gruppe" behandelt.
Und die Ausführung mit der interaktiven Jobfunktion auf der Benutzeroberfläche.
Der Klassenname sollte als pythonDateiname.PythonClassImplementingIlumJob
Das Gleiche können wir mit der API .
1. Gruppe erstellen
curl -X POST 'localhost:9888/api/v1/group' \
--form 'name="SparkPiInteractiveExample"' \
--form 'kind="JOB"' \
--form 'clusterName="Standard"' \
--form 'pyFiles=@"/Pfad/zum/ilum_python_simple_interactive.py"' \
--form 'Sprache="PYTHON"' API-Aufruf
{"groupId":"20230726-1638-mjrw3"} Ergebnis
2. Ausführung des Auftrags
curl -X POST 'localhost:9888/api/v1/group/20230726-1638-mjrw3/job/execute' \
-H 'Inhaltstyp: application/json' \
-d '{ "jobClass":"ilum_python_simple_interactive. SparkPiInteractiveExample", "jobConfig": {"partitions":"10"}, "type":"interactive_job_execute"}' API-Aufruf
{
"jobInstanceId":"20230726-1638-mjrw3-a1srahhu",
"jobId":"20230726-1638-mjrw3-wwt5a",
"groupId":"20230726-1638-mjrw3",
"startTime":1690390323154,
"endTime":1690390325200,
"jobClass":"ilum_python_simple_interactive. SparkPiInteractiveExample",
"jobConfig":{
"partitions":"10"
},
"result":"Pi ist ungefähr 3,149400",
"Fehler":null
} Ergebnis
2.2 Jobbeispiel mit numpy.
Schauen wir uns unser zweites Beispiel an.
aus pyspark.sql SparkSession importieren
aus pyspark.ml importieren Pipeline
von pyspark.ml.feature import StringIndexer, VectorAssembler
von pyspark.ml.classification import LogisticRegression
von ilum.api import IlumJob
Klasse LogisticRegressionJobExample(IlumJob):
def run(self, spark_session: SparkSession, config: dict) -> str:
df = spark_session.read.csv(config.get('inputFilePath', 's3a://ilum-files/Tel-churn.csv'), header=Wahr,
inferSchema=Wahr)
categoricalColumns = ['Geschlecht', 'Partner', 'Angehörige', 'PhoneService', 'MultipleLines', 'InternetService',
'OnlineSecurity', 'OnlineBackup', 'DeviceProtection', 'TechSupport', 'StreamingTV',
'StreamingMovies', 'Vertrag', 'Papierlose Abrechnung', 'Zahlungsmethode']
Stufen = []
für categoricalCol in categoricalColumns:
stringIndexer = StringIndexer(inputCol=kategorischCol, outputCol=kategorischCol + "Index")
stufen += [stringIndexer]
label_stringIdx = StringIndexer(inputCol="Abwanderung", outputCol="Beschriftung")
Phasen += [label_stringIdx]
numericCols = ['SeniorCitizen', 'Amtszeit', 'Monatliche Gebühren']
assemblerInputs = [c + "Index" für c in categoricalColumns] + numericCols
assembler = VectorAssembler(inputCols=assemblerInputs, outputCol="Funktionen")
Stufen += [Monteur]
pipeline = Pipeline(stages=stages)
pipelineModell = pipeline.fit(df)
df = pipelineModel.transform(df)
train, test = df.randomSplit([float(config.get('splitX', '0.7')), float(config.get('splitY', '0.3'))],
seed=int(config.get('seed', '42')))
lr = LogisticRegression(featuresCol="features", labelCol="label", maxIter=int(config.get('maxIter', '5')))
lrModel = lr.fit(Zug)
Vorhersagen = lrModel.transform(test)
return '{}'.format(predictions.select("customerID", "label", "prediction").limit(
int(config.get('rowLimit', '5'))).toJSON().collect()) 1. Wir packen den Job in eine Klasse, genau wie im vorherigen Beispiel:
Klasse LogisticRegressionJobExample(IlumJob):
def run(self, spark_session: SparkSession, config: dict) -> str:
# Joblogik hier Auch hier ist die Auftragslogik in der laufen Methode einer Klasse, die IlumJob , was Ilum hilft, die Arbeit effizient zu erledigen.
2. Alle Parameter, einschließlich der Parameter für die Datenpipeline (z. B. Dateipfade und Hyperparameter für die logistische Regression), werden aus dem Konfiguration Wörterbuch:
df = spark_session.read.csv(config.get('inputFilePath', 's3a://ilum-files/Tel-churn.csv'), header=Wahr, inferSchema=Wahr)
train, test = df.randomSplit([float(config.get('splitX', '0.7')), float(config.get('splitY', '0.3'))], seed=int(config.get('seed', '42')))
lr = LogisticRegression(featuresCol="features", labelCol="label", maxIter=int(config.get('maxIter', '5'))) Durch die Zentralisierung aller Parameter an einem Ort bietet Ilum eine einheitliche, konsistente Möglichkeit zur Konfiguration und Abstimmung des Auftrags.
Das Ergebnis des Auftrags wird nicht an einen bestimmten Speicherort geschrieben, sondern als JSON-Zeichenfolge zurückgegeben:
return '{}'.format(predictions.select("customerID", "label", "prediction").limit(int(config.get('rowLimit', '5'))).toJSON().collect()) Dies ermöglicht eine dynamischere und flexiblere Handhabung des Auftragsergebnisses, das dann je nach Bedarf der Anwendung weiterverarbeitet oder über eine API exponiert werden kann.
Dieser Code zeigt perfekt, wie wir PySpark-Jobs nahtlos in Ilum integrieren können, um interaktive, API-gesteuerte Datenverarbeitungspipelines zu ermöglichen. Von einfachen Beispielen wie der Pi-Approximation bis hin zu komplexeren Fällen wie der logistischen Regression sind die interaktiven Aufgaben von Ilum vielseitig, anpassungsfähig und effizient.
Schritt 3: Festlegen eines Microservices für Ihren Spark-Auftrag
Microservices bringen einen Paradigmenwechsel von der traditionellen monolithischen Anwendungsstruktur hin zu einem modulareren und agileren Ansatz. Durch die Aufteilung einer komplexen Anwendung in kleine, lose gekoppelte Dienste wird es einfacher, jeden Dienst unabhängig voneinander basierend auf bestimmten Anforderungen zu erstellen, zu verwalten und zu skalieren. Angewendet auf unseren Spark-Auftrag bedeutet dies, dass wir einen robusten Datenverarbeitungsdienst erstellen konnten, der skaliert, verwaltet und aktualisiert werden konnte, ohne andere Teile unseres Anwendungsstacks zu beeinträchtigen.
Die Stärke der Umwandlung Ihres Spark-Auftrags in einen Microservice liegt in seiner Vielseitigkeit, Skalierbarkeit und Interaktionsmöglichkeiten in Echtzeit. Ein Microservice ist eine unabhängig bereitstellbare Komponente einer Anwendung, die als separater Prozess ausgeführt wird. Es kommuniziert über klar definierte APIs mit anderen Komponenten und gibt Ihnen die Freiheit, jeden Microservice unabhängig voneinander zu entwerfen, zu entwickeln, bereitzustellen und zu skalieren.
Im Kontext von Ilum kann ein interaktiver Spark-Auftrag als Microservice behandelt werden. Die "run"-Methode des Auftrags fungiert als API-Endpunkt. Jedes Mal, wenn Sie diese Methode über die API von Ilum aufrufen, stellen Sie eine Anfrage an diesen Microservice. Dies eröffnet das Potenzial für Echtzeitinteraktionen mit Ihrem Spark-Auftrag.
Sie können von verschiedenen Anwendungen oder Skripten aus Anforderungen an Ihren Microservice senden, Daten abrufen und Ergebnisse im laufenden Betrieb verarbeiten. Darüber hinaus eröffnet es die Möglichkeit, komplexere, serviceorientierte Architekturen rund um Ihre Datenverarbeitungspipelines aufzubauen.
Ein wesentlicher Vorteil dieses Setups ist die Skalierbarkeit. Über die Ilum UI oder API können Sie Ihren Job (Microservice) je nach Last oder Rechenkomplexität nach oben oder unten skalieren. Sie müssen sich keine Gedanken über die manuelle Verwaltung von Ressourcen oder den Lastausgleich machen. Der interne Load Balancer von Ilum verteilt API-Aufrufe zwischen den Instanzen Ihres Spark-Auftrags und sorgt so für eine effiziente Ressourcennutzung.
Beachten Sie, dass die tatsächliche Verarbeitungszeit des Auftrags von der Komplexität des Spark-Auftrags und den ihm zugeordneten Ressourcen abhängt. Mit der Skalierbarkeit von Kubernetes können Sie Ihre Ressourcen jedoch problemlos skalieren, wenn die Anforderungen Ihres Auftrags wachsen.
Diese Kombination aus Ilum, Apache Spark und Microservices ermöglicht eine neue, agile Art der Verarbeitung Ihrer Daten – effizient, skalierbar und reaktionsschnell!
Der Game-Changer in der Daten-Microservice-Architektur
Wir haben einen langen Weg zurückgelegt, seit wir mit Ilum einen einfachen Python-Apache Spark-Job in einen vollwertigen Microservice umgewandelt haben. Wir haben gesehen, wie einfach es ist, einen Spark-Job zu schreiben, ihn für den interaktiven Modus anzupassen und ihn schließlich mit Hilfe der robusten API von Ilum als Microservice bereitzustellen. Auf dem Weg dorthin haben wir die Leistungsfähigkeit von Python, die Fähigkeiten von Apache Spark und die Flexibilität und Skalierbarkeit von Ilum genutzt. Diese Kombination hat nicht nur unsere Datenverarbeitungsfähigkeiten verändert, sondern auch die Art und Weise, wie wir über Datenarchitektur denken.
Die Reise hört hier nicht auf. Mit der vollständigen Python-Unterstützung auf Ilum eröffnet sich eine neue Welt der Möglichkeiten für die Datenverarbeitung und -analyse. Während wir Ilum weiter ausbauen und verbessern, freuen wir uns über die zukünftigen Möglichkeiten, die Python für unsere Plattform bietet. Wir glauben, dass wir mit Python und Ilum zusammen erst am Anfang stehen, um neu zu definieren, was in der Welt der Daten-Microservice-Architektur möglich ist.
Begleiten Sie uns auf dieser spannenden Reise und lassen Sie uns gemeinsam die Zukunft der Datenverarbeitung gestalten!