Hinweis:

AVRO-Nachrichten mit Oracle Cloud Infrastructure Streaming und OCI Data Flow mit Micro-Batch-Verarbeitung streamen

Einführung

In der heutigen datengesteuerten Landschaft ist die Möglichkeit, Echtzeit-Datenstreams zu verarbeiten und zu analysieren, von entscheidender Bedeutung für Unternehmen, die Erkenntnisse gewinnen und schnell auf sich ändernde Bedingungen reagieren möchten. Streaming-Datenverarbeitungstechnologien haben sich als leistungsstarke Lösungen für die Verarbeitung von Datenstreams mit hohem Volumen etabliert. In diesem Tutorial wird ein innovativer Ansatz für die effiziente Streamung von AVRO-Nachrichten mit Oracle Cloud Infrastructure-(OCI-)Streaming in Kombination mit der Micro-Batch-Verarbeitungstechnik vorgestellt und mit den serverlosen Funktionen von Oracle Functions basierend auf dem Open-Source-FN-Projekt erweitert.

Einführung in AVRO und Streamingdaten

AVRO, ein weit verbreitetes Datenserialisierungsformat, ist bekannt für seine Effizienz bei der Darstellung komplexer Datenstrukturen und deren Kompatibilität mit verschiedenen Programmiersprachen. Durch die Integration mit Streaming-Technologien können Unternehmen Daten nahezu in Echtzeit übertragen und verarbeiten. So können sie wertvolle Erkenntnisse ohne die Latenz extrahieren, die in der Regel mit der Batchverarbeitung verbunden ist.

OCI Streaming: Daten in Echtzeit unterstützen

Oracle Cloud Infrastructure (OCI) verfügt über eine Reihe von Tools für die Verarbeitung von Daten in der Cloud. OCI Streaming ist ein solcher Service, der auf Echtzeitdatenstreams mit hohem Durchsatz zugeschnitten ist. Durch die Nutzung von OCI Streaming können Entwickler skalierbare und zuverlässige Datenpipelines erstellen, die Datenstreams effizient erfassen, verarbeiten und verteilen.

Von OCI Data Flow verwaltetes Spark: Keine Lock-In-Lösung

Oracle Cloud Infrastructure (OCI) Data Flow ist ein vollständig verwalteter Apache Spark-Service, der Verarbeitungsaufgaben für extrem große Datasets ohne Infrastruktur zum Bereitstellen oder Verwalten ausführt.

Bei der Micro-Batch-Verarbeitung werden eingehende Datenstreams mithilfe von Zeit oder Größe als Kriterien in kompakte Batches aufgeteilt. Diese Batches werden dann als kleinere Jobs verarbeitet. Im Gegensatz zur konstanten und individuellen Verarbeitung von Datensätzen bei der Stream-Verarbeitung führt die Micro-Batch-Verarbeitung vor der Verarbeitung ein wenig Verzögerung und Speicherung ein, was eine bessere Kontrolle darüber ermöglicht, was mit den Daten zu tun ist. Im Gegensatz zur herkömmlichen Batch-Verarbeitung, bei der Big Data Sets in Intervallen verarbeitet werden, bietet die Micro-Batch-Verarbeitung nahezu Echtzeit-Verarbeitung und -Bereitstellung von Ergebnissen.

Synergie freigeben: OCI Streaming, OCI Data Flow und Oracle Functions

Dieses Tutorial beschreibt die Fusion von OCI Streaming, von OCI Data Flow verwaltetem Spark Streaming und Oracle Functions. Wir führen Sie durch den Prozess der Einrichtung einer End-to-End-Streaming-Datenpipeline, die AVRO-codierte Nachrichten aufnimmt, sie mit von OCI Data Flow verwalteten Spark-Mikrobatchverarbeitungsfunktionen effizient verarbeitet und serverlose ereignisgesteuerte Verarbeitung mit Oracle Functions einführt.

Zielsetzung

Verwenden Sie die von OCI Streaming und OCI Data Flow verwaltete Spark-Micro-Batch-Verarbeitung, um eine effiziente Echtzeit-Datenverarbeitungspipeline im AVRO-Format zu erstellen.

Wichtig: Dieses Tutorial dient ausschließlich zu Schulungs- und Studienzwecken. Es bietet eine Umgebung, in der Lerner experimentieren und praktische Erfahrungen in einer kontrollierten Umgebung sammeln können. Beachten Sie, dass die in dieser Übung verwendeten Sicherheitskonfigurationen und -praktiken möglicherweise nicht für reale Szenarios geeignet sind.

Sicherheitsbetrachtungen für echte Anwendungen sind oft viel komplexer und dynamischer. Daher ist es wichtig, vor der Implementierung einer der hier in einer Produktionsumgebung aufgezeigten Techniken oder Konfigurationen eine umfassende Sicherheitsbewertung und -überprüfung durchzuführen. Diese Überprüfung sollte alle Aspekte der Sicherheit umfassen, einschließlich Zugriffskontrolle, Verschlüsselung, Überwachung und Compliance, um sicherzustellen, dass das System den Sicherheitsrichtlinien und -standards der Organisation entspricht.

Beim Übergang von einer Übungsumgebung zu einem realen Deployment sollte die Sicherheit immer eine oberste Priorität sein.

Prozessfluss
T0_1

Allgemeine Architektur
T0_1

Voraussetzungen - Oracle Cloud Infrastructure

Voraussetzungen - Lokale Rechnerumgebung

Aufgabe 1: Dynamische Gruppen einrichten

  1. Gehen Sie zu Ihrer Domain, klicken Sie auf Dynamische Gruppen, und erstellen Sie die folgenden Gruppen.

    Gruppenname: MyFunctions

    ALL {resource.type = 'fnfunc', resource.compartment.id = 'pasteYourCompartmentID'}

    Gruppenname: ContainerIntances

    ALL {resource.type='compute-container-instances',  resource.compartment.id = 'pasteYourCompartmentID'}

    Gruppenname: DataFlowDynamicGroup

    ALL {resource.type='dataflowrun', resource.compartment.id = 'pasteYourCompartmentID'}

Aufgabe 2: Policys erstellen

Aufgabe 3: Speicher-Buckets erstellen und AVRO-Schema hochladen

  1. Gehen Sie zu Buckets, klicken Sie auf Bucket erstellen, und erstellen Sie einen neuen Bucket mit dem Namen AVRO-schema-bucket, um die AVRO-Schemadatei zu speichern.

    T3_1

  2. Wählen Sie jetzt Ihren Bucket aus, und wiederholen Sie den HINWEIS des Namespace. Er wird später benötigt.

    T3_1

  3. Laden Sie die Datei user.asvc in diesen erstellten Bucket hoch.

    T3_1

Aufgabe 4: Privates OCI-Streaming-Thema erstellen

  1. Gehen Sie zu Analysen und KI, klicken Sie auf Streaming, und erstellen Sie einen neuen Stream namens FrontDoorTopic.

    T4_0

  2. Wählen Sie Streampools aus, klicken Sie auf PrivatePool, und klicken Sie dann auf die Option Kafka-Verbindungseinstellungen, und HINWEIS abrufen der Felder wird später benötigt.

    T4_0

Aufgabe 5: AUTH TOKEN erstellen

AUTH TOKEN für Ihren Benutzer erstellen. Dies ist erforderlich, um mit dem Kafka-Thema zu arbeiten

  1. Klicken Sie am oberen rechten Benutzersymbol, und wählen Sie dann die Option Benutzereinstellungen.

  2. Klicken Sie auf Authentifizierungstoken, und generieren Sie ein neues Token und HINWEIS abrufen des Tokens.

    T4_1

Aufgabe 6: Container-Registry erstellen

  1. Gehen Sie zum Menü Entwicklerservices, klicken Sie auf Container-Registry, und erstellen Sie die folgenden privaten Repositorys.

    Repository-Name Typ
    api-avro-sample_a Privat
    api-avro-sample_b Privat
    fn-recep-avro Privat

  2. Prüfen Sie die Repositorys und TAKE NOTE des Namespace.

    T6_1

  3. Öffnen Sie die Terminalshell, in der OCI CLI und Docker installiert sind, und fahren Sie mit der Anmeldung in der Registry fort. Prüfen Sie, welche URL für Ihre REGION korrekt ist. In diesem Tutorial verwenden wir Brazil East (Sao Paulo), wo die Registry-URL gru.ocir.io lautet.

    docker login gru.ocir.io
Username: <your container namespace>/youruser
Password: YOUR_AUTH_TOKEN_CREATED_EARLIER

    T6_1

Aufgabe 7: OCI Vault erstellen

Erstellen Sie den OCI Vault, und geben Sie die erforderlichen Variablen an, die später in diesem Tutorial verwendet werden.

  1. Gehen Sie zu Identifizieren und Sicherheit, klicken Sie auf Vault und dann auf Vault erstellen.

    T7_1new

  2. Wählen Sie den neuen Vault aus, und erstellen Sie Masterverschlüsselungsschlüssel dafür.

    T7_1new

  3. Erstellen Sie ein neues Secret mit dem Namen AUTH_KEY, und fügen Sie den zuvor erstellten Authentifizierungsschlüssel ein.

    T7_1new

  4. Wiederholen Sie den Secret-Erstellungsprozess, und erstellen Sie die folgenden neuen Secrets:

    Variablenname Wert
    KAFKA_BOOTSTRAPSERVER "Der Boostrap-Server aus Ihrer OCI Streaming-Konfiguration"
    KAFKA_TOPIC “FrontDoorTopic”
    KAFKA_USERNAME "Ihr Benutzername + Streampool-ID aus Ihrer OCI Streaming-Konfiguration"
    AUTH_KEY "Ihr AUTH-Token, das Sie in früheren Schritten erstellt haben"

  5. Notieren Sie sich die Secret-OCID, die für jedes Secret erstellt wurde, und erstellen Sie eine neue Konfigurationsdatei.

    • Die Datei config.properties enthält die Zuordnungsvariablen von der Anwendung zu den Vault-Secrets-OCIDs. Die Anwendung verwendet diese Datei, um zu identifizieren, welche Vault Secrets während der Laufzeit erfasst werden müssen.

    • Erstellen Sie eine neue Datei auf Ihrem lokalen Rechner, auf dem Sie Zugriff auf OCI-CLI haben:
      Ersetzen Sie Ihre OCID für jeden Secreat-Dateinamen
      : config.properties

      kafka_bootstrapserver_vaultOCID=ocid1.vaultsecret.REPLACE-WITH-YOURS
kafka_topic_vaultOCID=ocid1.vaultsecret.REPLACE-WITH-YOURSxxxxxx
kafka_username_vaultOCID=ocid1.vaultsecret.REPLACE-WITH-YOURS
auth_token_vaultOCID=ocid1.vaultsecret.oc1.REPLACE-WITH-YOURS

  6. Gehen Sie zu Buckets, klicken Sie auf Bucket erstellen, und erstellen Sie einen neuen Bucket mit dem Namen config, um die Datei config.properties zu speichern.

  7. Laden Sie die Datei config.properties in den Speicher-Bucket config hoch

    ls -lrt config.properties
oci os object put -bn config --file config.properties --force

    T7_1new

Aufgabe 8: Erstellen Sie eine einfache AVRO-Nachricht, und speichern Sie sie mit dem bereitgestellten python-Beispielcode in einer Datei

  1. Öffnen Sie das Shell-Terminal, in dem OCI CLI, Docker und Python3 installiert sind, und erstellen Sie eine neue AVRO-Datei mit einer einzelnen Nachricht, die auf dem gleichen AVRO-Schema basiert, das wir zuvor in Object Storage hochgeladen haben.

    Hinweis: Sie müssen die Python-Version prüfen, Python 3.9.16 in diesem Tutorial verwenden, frühere Versionen funktionieren möglicherweise nicht.

  2. Hier erhalten Sie den Code Create_avro_sample.zip.

  3. Dekomprimieren Sie es an den von Ihnen ausgewählten Ort, und führen Sie das Programm aus, um eine AVRO-Beispielnachricht zu generieren:

    cd ~
mkdir create_avro_sample
cd create_avro_sample
unzip CreateAVRO_SampleFile.zip
# Check the files are there
ls -lrt
# install the python dependencies on requirements.txt
pip3 install -r requirements.txt
# Run the program and create an AVRO message file
python3 create_avro_sample.py meu_file.bin '{"id":10029,"name":"John","email":"john@bla.com"}'

    T8_1 T8_1 T8_1

Aufgabe 9: OCI-Funktion für den Empfang der AVRO-Nachricht und die Veröffentlichung im OCI Streaming-Thema erstellen

  1. Gehen Sie zu Entwicklerservices, klicken Sie unter Functions auf Anwendungen und dann auf Anwendung erstellen.

    T9_1

  2. Gehen Sie zu der Terminalshell, in der Docker, OCI CLI und FN CLI installiert sind, und führen Sie die folgenden Befehle aus, um die Funktion zu initialisieren.

    Hinweis: Wenn Sie die Schritte ausgeführt haben, wurde der Docker-Anmeldebefehl bereits ausgeführt. Wenn nicht, fahren Sie mit dem Docker-Anmeldeschritt in der Aufgabe Container-Registry erstellen fort.

    fn create context oci-cloud --provider oracle
fn use context oci-cloud
fn update context oracle.compartment-id PASTE_YOUR_COMPARTMENT_OCID
fn update context api-url https://functions.sa-saopaulo-1.oraclecloud.com
fn update context registry gru.ocir.io/PASTE_YOUR_REGISTRY_NAMESPACE

    Hinweis: In diesem Tutorial wird die Region Brazil East(Sao Paulo) verwendet. Wenn Sie eine andere Region verwenden, müssen Sie die Speicherorte api-url und registry ändern.

    T9_1

  3. Erstellen Sie eine einfache Hello-world-Funktion, um sicherzustellen, dass alle Einstellungen korrekt sind.

    fn init --runtime python fn-recep-avro
cd fn-recep-avro
fn deploy --app MyReceptionApp
fn invoke MyReceptionApp fn-recep-avro

    T9_1

  4. Rufen Sie den Beispielcode der AVRO-Funktion in der Datei fn-recep-AVRO.zip ab, und ersetzen Sie den hello-world-Code, den wir zuvor erstellt haben. Sie müssen die Dateien func.py und requirements.txt abrufen, damit Sie arbeiten können.

    # Check you have the right code for func.py & requirements.txt (you got from zip file)
ls -lrt

    T9_1

  5. Neuen Code erstellen und Funktion bereitstellen

    fn deploy --app MyReceptionApp

    T9_1

  6. Um die Funktion aufzurufen, müssen wir eine AVRO-Nachricht als Parameter übergeben. Dazu verwenden wir die erstellte AVRO-Beispielnachrichtendatei aus den vorherigen Schritten. Beim ersten Aufruf einer Funktion dauert es etwas länger, da sie gestartet werden muss.

    # Check where you created the sample avro message file
ls -lrt ../create_avro_sample/

# Invoke the function to check if it's working as expected
echo -n -e "$(cat ../create_avro_sample/meu_file.bin)" | fn invoke MyReceptionApp fn-recep-avro

    T9_1

Aufgabe 10: API-Gateway zur Anzeige der Funktion erstellen

  1. Klicken Sie in der Konsole auf Entwicklerservices, dann unter API-Management auf Gateways, Gateway erstellen.

    T10_1

  2. Klicken Sie nach der Erstellung auf die Option Deployments, und klicken Sie dann auf Deployment erstellen.

    Name: RecepFunction
    Pfadpräfix: /

    • Wählen Sie unter "Authentifizierung" die Option Keine Authentifizierung, da dies eine einfache Übung ist und keine API-Authentifizierung implementiert ist. Das Hauptziel ist hier, einen HTTPS-Aufruf zu demonstrieren, der eine binäre AVRO-Nachricht über eine API übergibt. Im Rahmen dieser Übung implementieren wir keine Authentifizierungsmethode für diese einfache Übung.
    • Bevor Sie zu einer echten Lebensumgebung wechseln, befolgen Sie die Best Practices für die Sicherheit von API Gateway.
    • Weitere Details finden Sie unter API-Gateways und -Ressourcen sichern.

    Route 1: Pfad: /

    Methos: POST
    Backend-Typ: Oracle-Funktionen
    Anwendung: Wählen Sie Ihre Funktion aus

    T9_1

    T9_1

    T9_1

    T9_1

  3. Prüfen Sie den API-Gateway-Endpunkt, und notieren Sie sich.

    T9_1

  4. Öffnen Sie das Linux-Shell-Terminal, und rufen Sie das API-Gateway auf. Ersetzen Sie die API-URL durch den richtigen Endpunkt, den Sie im vorherigen Schritt erhalten haben.

    cd create_avro_sample/
ls -lrt
curl -X POST -H "Content-Type: application/octet-stream" \
     -d "$(echo -n -e "$(cat meu_file.bin)")" \
     https://xxxxxxxxxxxxx.apigateway.sa-saopaulo-1.oci.customer-oci.com/

    T9_1

Checkpoint

T9_1

Aufgabe 11: Containerimage für API-Typ A erstellen

Hinweis: Der API-Typ A und B-Code ist im Wesentlichen mit nur einer anderen Headernachricht identisch, um zwei verschiedene APIs zu simulieren.

  1. Rufen Sie den Code aus dem API-Typ A ab, und dekomprimieren Sie ihn in Ihrem Linux-Shell-Terminal api-avro-sample_a.zip.

  2. Rufen Sie den Namespace der Container-Registry ab, den Sie in den vorherigen Schritten erhalten haben, und erstellen Sie den Speicherort der Anwendungs-Registry entsprechend dem folgenden Muster. Die ocir url basiert auf Ihrer Region, d.h. gru.ocir.io für Brasil East(SaoPaulo)

    [ocir url]/[Ihr Namespace]/api-avro-sample_a:neueste

  3. Erstellen und übergeben Sie in Ihrem Linux-Shell-Terminal das Docker-Image für diese API.

    ls -lrt
docker build . -t gru.ocir.io/yournamespace/api-avro-sample_a:latest
docker push gru.ocir.io/yournamespace/api-avro-sample_a:latest

    T10_1 T10_1

Aufgabe 12: Containerimage für API-Typ B erstellen

  1. Rufen Sie den Code aus dem API-Typ B ab, und dekomprimieren Sie ihn in Ihrem Linux-Shell-Terminal api-avro-sample_b.zip.

  2. Rufen Sie den Namespace der Container-Registry ab, den Sie in den vorherigen Schritten erhalten haben, und erstellen Sie den Speicherort der Anwendungs-Registry entsprechend dem folgenden Muster. Die ocir url basiert auf Ihrer Region, d.h. gru.ocir.io für Brasil East(SaoPaulo)

    [ocir url]/[Ihr Namespace]/api-avro-sample_b:neueste

  3. Erstellen und übergeben Sie in Ihrem Linux-Shell-Terminal das Docker-Image für diese API.

    ls -lrt
docker build . -t gru.ocir.io/yournamespace/api-avro-sample_b:latest
docker push gru.ocir.io/yournamespace/api-avro-sample_b:latest

    T10_1

    T10_1

  4. Prüfen Sie auf der Container-Registry-Seite, ob das Image erfolgreich übertragen wurde.

    T10_1

Aufgabe 13: APIs im Containerservice bereitstellen

  1. Gehen Sie zu Entwicklerservices und Containerinstanzen, und klicken Sie auf Containerinstanz erstellen.

    T13_1

    T13_1

  2. Wiederholen Sie Schritt 1 für API-type-b, und wählen Sie das richtige Image für die TYPE B-API aus.

    1. Gehen Sie zu Entwicklerservices, Containerinstanzen, und klicken Sie auf Containerinstanz erstellen, und wiederholen Sie die Schritte zum Deployment des API-Typs B.

    2. Rufen Sie die interne FQDN-Adresse aus Ihren Containerinstanzen ab.

      T14_1

      • Klicken Sie auf die Containerinstanz, und notieren Sie sich jede interne FQDN-Adresse.

      T14_1

    3. Gehen Sie zu Identifizieren und Sicherheit, klicken Sie auf Vault, wählen Sie Ihren VAULT aus, und erstellen Sie zwei neue Secrets.

      Secret-Name Wert
      API_TYPE_A_URL Private interne FQDN-Adresse für API-Typ A einfügen
      API_TYPE_B_URL Private interne FQDN-Adresse für API-Typ B einfügen

      Notieren Sie sich die einzelnen Secret-OCIDs.

      Der Vault sollte wie folgt aussehen:

      T14_1

    4. Bearbeiten Sie die Datei config.properties, die Sie in den config-Speicher-Bucket hochgeladen haben, und fügen Sie neue Einträge für die Secret-OCID hinzu

      ls -lrt config.properties
vi config.properties
api_type_a_url_vaultOCID=paste_API_TYPE_A_URL_secretOCID
api_type_b_url_vaultOCID=paste_API_TYPE_B_URL_secretOCID

# After save, please upload the new version to Object Storage
cat config.properties
oci os object put -bn config --file config.properties --force

      Ihre Datei sollte wie folgt aussehen:
      T14_1

      T14_1

Aufgabe 14: Testen Sie die APIs mit create_avro_sample.py

  1. Gehen Sie zu Ihrem Linux-Shell-Terminal, in dem Sie create_avro_sample.py aus Aufgabe 7 gespeichert haben, und erstellen Sie neue Nachrichten zum Testen von API-Aufrufen. Wir erstellen zwei neue AVRO-Dateien mit unterschiedlichen IDs (1010 und 1020), die wir als Filter im Spark Stream (DataFlow)-Programm verwenden.

    ls -lrt
python3 create_avro_sample.py type_a_message.bin '{"id":1010,"name":"Paul that goes to API type A","email":"paul@bla.com"}'

python3 create_avro_sample.py type_b_message.bin '{"id":1020,"name":"Mary that goes to API type B","email":"mary@bla.com"}'

    T14_1

  2. Rufen Sie die APIs auf, die die zu testende AVRO-Nachricht übergeben. Gehen Sie zur Seite Containerinstanzen, und rufen Sie die interne FQDN-Adresse für jede der APIs api-type-a und api-type-b ab. Denken Sie daran, die folgende URL für die entsprechende interne FQDN-Adresse aus Ihren APIs zu ersetzen.

    ls -lrt type*

curl -i -X POST -H "Content-Type: application/octet-stream" \
   --data-binary "@type_a_message.bin" \
   xxx.xx.x.xxx

curl -i -X POST -H "Content-Type: application/octet-stream" \
   --data-binary "@type_b_message.bin" \
   xxx.xxx.xx.xxx

    T14_1

Aufgabe 15: Java Spark-Streaminganwendung einrichten

  1. Gehen Sie zu Buckets, klicken Sie auf Bucket erstellen, und erstellen Sie zwei neue Buckets namens dataflow-app-avro und dataflow-logs-avro. Damit wird die Java-Anwendung hochgeladen.

  2. Prüfen Sie die java-Umgebungsversionen.

    Java

    java 11.0.8 2020-07-14 LTS
Java(TM) SE Runtime Environment 18.9 (build 11.0.8+10-LTS)
Java HotSpot(TM) 64-Bit Server VM 18.9 (build 11.0.8+10-LTS, mixed mode)

    Maven

    Apache Maven 3.5.4 (Red Hat 3.5.4-5)
Maven home: /usr/share/maven
Java version: 11.0.20, vendor: Red Hat, Inc., runtime: /usr/lib/jvm/java-11-openjdk-11.0.20.0.8-3.0.1.el8.x86_64
Default locale: en_US, platform encoding: ANSI_X3.4-1968
OS name: "linux", version: "5.15.0-103.114.4.el8uek.x86_64", arch: "amd64", family: "unix"

  3. Laden Sie den Beispielcode herunter, und dekomprimieren Sie ihn in Ihrer lokalen Umgebung mit oci-cli, docker, java und maven: spark-consume-avro-message.zip.

    unzip spark-consume-avro-message.zip
cd spark-consume-avro-message
ls -lrt

    T15_1 T15_1

    Ein wenig Einblick in den Proxycode, um Containerinstanztypen A und B aufzurufen.

    Prüfen Sie die Hauptprogrammdatei .src/main/java/example/Example.java.... T15_1

  4. Da dieses Java-Programm eine Library zur Verarbeitung der Funkenavro verwendet, müssen wir die Abhängigkeit verpacken, um sie an den Datenfluss zu übergeben. Dazu verwenden wir Data Flow Dependency Packager. Wenn Sie weitere Details benötigen, können Sie zu Data Flow Dependency Packager navigieren.

    Das Package org.apache.spark:spark-avro_2.12:3.2.1 wurde bereits in der Datei packages.txt deklariert. Sie müssen es nur mit folgendem Befehl verpacken:

    docker run --privileged --platform linux/amd64 --rm -v $(pwd):/opt/dataflow  --pull always -it phx.ocir.io/oracle/dataflow/dependency-packager:latest -p 3.8

    T15_1 T15_1 T15_1

  5. Laden Sie die Datei archive.zip mit der oci-cli in den Speicher-Bucket dataflow-app-avro hoch.

    oci os object put -bn dataflow-app-avro --file archive.zip --force

  6. Kompilieren, verpacken Sie die Java-Anwendung, und laden Sie sie in den Speicher-Bucket dataflow-app-avro hoch

    ls -lrt
mvn clean install

    T15_1
    ...reduzierte Anzahl Zeilen des Kompilierungslogs... T15_1

    # upload the JAR file to the storage bucket
oci os object put -bn dataflow-app-avro --file target/consumekafka-1.0-SNAPSHOT.jar --force

    T15_1

  7. Prüfen Sie den aktuellen dataflow-app-avro-Speicher-Bucket, und stellen Sie sicher, dass er wie folgt aussieht.

    T15_1

  8. Gehen Sie zu Analysen und KI, klicken Sie unter Data Lake auf Data Flow, wählen Sie das linke Menü Private Endpunkte aus, und klicken Sie auf Privaten Endpunkt erstellen.

    • Der PRIVATE Endpunkt ist erforderlich, da wir das PRIVATE-Subnetz für die Containerinstanzen und den OCI Streaming Pool verwenden.

    • Stellen Sie sicher, dass Sie die DNS-Zonen mit dem internen FQDN aus den OCI-Containerinstanzen und dem OCI Streaming Pool durch Komma getrennt ausfüllen.

      T15_1

  9. Gehen Sie zu Analysen und KI, und klicken Sie unter Data Lake auf Data Flow, Anwendung erstellen.

    T15_1
    T15_1
    T15_1
    T15_1
    T15_1
    T15_1

    • Wählen Sie nach der Erstellung den Datenfluss spark-lab-avro aus, und klicken Sie auf Ausführen, um das Programm zu starten. Es dauert in der Regel bis zu 8 Minuten.

      T15_1
      T15_1

  10. Prüfen Sie die Anwendung "Running dataflow", und öffnen Sie SparkUI, um die aktuellen Jobs anzuzeigen, und die App arbeitet.

    T15_1

    T15_1

    T15_1

Aufgabe 16: Ablauf validieren

Rufen Sie die Funktion auf, und übergeben Sie eine Nachricht, um zu prüfen, ob der gesamte Ablauf wie erwartet funktioniert.

  1. Öffnen Sie das Linux-Shell-Terminal, in dem Sie die Beispielnachrichten type_a_message.bin und type_b_message.bin erstellt haben, und senden Sie die Nachricht. Ersetzen Sie die API-URL durch den richtigen Endpunkt, den Sie beim Erstellen des API-Gateways erhalten haben.

    cd create_avro_sample/
ls -lrt
curl -X POST -H "Content-Type: application/octet-stream" \
   -d "$(echo -n -e "$(cat type_a_message.bin)")" \
   https://xxxxxxxxxxxxx.apigateway.sa-saopaulo-1.oci.customer-oci.com/

    T16_1

  2. Prüfen Sie, ob der API-Typ A aufgerufen wurde, indem Sie die Logs in der Containerinstanz prüfen.

    T16_1 T16_1

Sie können den Prozess wiederholen und eine type_b_message.bin-Datei senden. Dabei wird der Typ B-Containerinstanz aufgerufen.

T9_1

Danksagungen

Weitere Lernressourcen

Sehen Sie sich andere Übungen zu docs.oracle.com/learn an, oder greifen Sie auf weitere kostenlose Lerninhalte im Oracle Learning YouTube-Kanal zu. Besuchen Sie außerdem die Website education.oracle.com/learning-explorer, um Oracle Learning Explorer zu werden.

Produktdokumentation finden Sie im Oracle Help Center.