Hinweis:

Dieses Tutorial erfordert Zugriff auf Oracle Cloud. Informationen zum Registrieren eines kostenlosen Accounts finden Sie unter Erste Schritte mit Oracle Cloud Infrastructure Free Tier.
Er verwendet Beispielwerte für Oracle Cloud Infrastructure-Zugangsdaten, Mandanten und Compartments. Ersetzen Sie diese Werte beim Durchführen Ihrer Übung durch spezifische Werte für Ihre Cloud-Umgebung.

Streamanalysen mit Oracle Cloud Infrastructure Streaming und Oracle Database

Einführung

Oracle Cloud Infrastructure Streaming ist ein hoch skalierbarer und hochverfügbarer Streaming-Service auf Oracle Cloud Infrastructure (OCI). Der Stream-Service ist vollständig serverlos und API-kompatibel mit Apache Kafka.

Oracle SQL-Zugriff auf Kafka ist ein Oracle PL/SQL-Package und ein Präprozessor für externe Tabellen. Damit kann Oracle Database Ereignisse und Nachrichten aus Kafka-Topics als Ansichten oder Tabellen in Oracle Database lesen und verarbeiten. Sobald sich die Daten aus Kafka in einer Oracle Database-Tabelle befinden oder in einer Oracle Database-View angezeigt werden, können sie wie alle anderen Daten in Oracle Database mit der vollen Leistung von Oracle PL/SQL abgefragt werden.

Wenn Sie Daten mit Oracle SQL-Zugriff auf Kafka-fähige Ansichten abrufen, werden Daten nicht in Oracle Database persistiert. Wenn Sie jedoch den Oracle SQL-Zugriff auf Kafka-basierte Tabellen verwenden, wird er in Oracle Database dauerhaft gespeichert. Daher bietet Oracle SQL-Zugriff auf Kafka Entwicklern volle Flexibilität hinsichtlich der Persistenz der Streamingdaten auf Oracle Database. Einen guten Überblick und Anwendungsfall für Oracle SQL-Zugriff auf Kafka finden Sie in diesem Blogpost unter Integrating Data-in-Motion with Data-at-Rest with Oracle SQL Access to Kafka Views.

Kurz gesagt ermöglicht der Oracle SQL-Zugriff auf Kafka die Verarbeitung von Daten in der Ruhephase (innerhalb von Oracle Database-Tabellen) mit Oracle PL/SQL. Anwendungen wie JDBC-(Java Database Connectivity-)Anwendungen können also Echtzeitereignisse aus Kafka- und kritischen Oracle Database-Daten innerhalb von Oracle Database-Transaktionen verarbeiten, die ACID-Garantien bieten. Dies ist nicht einfach möglich, wenn eine Anwendung Kafka-Ereignisse und -Daten separat von Oracle Database abruft.

Vorteile

Mit Oracle SQL-Zugriff auf Kafka können Kunden Echtzeit-Streamanalysejobs mit Oracle PL/SQL ausführen, indem sie Daten direkt aus dem Stream-Service lesen, ohne ihn jemals in einen externen Datenspeicher verschieben zu müssen.
Kunden können den Oracle SQL-Zugriff auf Kafka auch ausschließlich für die Datenübertragung vom Stream-Service in Oracle Database ohne jegliche Verarbeitung verwenden.
Der Streamverarbeitungsvorgang kann im Kontext einer von der Anwendung gesteuerten Oracle ACID-Transaktion ausgeführt werden.
Oracle SQL-Zugriff auf Kafka fungiert nur als Kafka-Consumer und nie als Kafka-Producer. Die gesamte Offset-Verwaltung wird von OSaK verarbeitet. Diese Informationen werden in Metadatentabellen in Oracle Database gespeichert. Daher ermöglicht der Oracle SQL-Zugriff auf Kafka die exakte Once-Verarbeitungssemantik, da er Partitions-Offset für Kafka und den Stream-Service und die Anwendungsdaten in einer einzelnen ACID-konformen Oracle Database-Transaktion in Oracle Database festschreiben kann. Dadurch wird das Verlieren oder erneutes Lesen von Streaming-Datensätzen vermieden.

Anwendungsfälle

Stellen Sie sich jeden Anwendungsfall vor, in dem Sie Ihre Streamingdaten verknüpfen oder mit Ihren relationalen Daten verknüpfen möchten. Beispiel:

Sie möchten die Streamingdaten von Ihren Chatty IoT-Geräten (am wahrscheinlichsten an Ihrem Standort des Kunden) mit den relevanten Kundeninformationen kombinieren, die in der relationalen Oracle Database Ihrer Quellwahrheit gespeichert sind.
Sie möchten genaue exponentielle gleitende Durchschnittswerte für Aktienkurse berechnen, die in den Stream-Service streamen. Sie müssen dies mit einer exakten Semantik tun. Sie möchten diese Daten mit statischen Informationen zu diesem Bestand kombinieren, wie Name, Unternehmens-ID, Marktkapitalisierung usw., die in Ihrer Oracle Database gespeichert sind.

Hinweis: Da der Oracle SQL-Zugriff auf Kafka ein PL/SQL-Package ist, das manuell auf dem Oracle-Serverhost installiert werden muss, kann er nur mit selbstverwalteten (On-Premise- oder On-Cloud-)Oracle Database-Installationen verwendet werden. Er kann nicht mit serverlosen Oracle Database-Angeboten wie Oracle Autonomous Database auf Oracle Cloud Infrastructure (OCI) funktionieren.

Da der Stream-Service API-kompatibel mit Kafka ist, funktioniert er nahtlos mit Oracle SQL-Zugriff auf Kafka. Vom Oracle SQL-Zugriff bis zur Kafka-Point of View ist ein Stream Service Stream Pool ein Kafka-Cluster, und ein Stream Service Stream ist ein Thema im Kafka-Cluster.

In diesem Tutorial wird gezeigt, wie einfach wir den Oracle SQL-Zugriff auf Kafka mit dem Stream-Service integrieren können.

Hinweis: Wenn Sie bereits mit dem Oracle SQL-Zugriff auf Kafka, den Stream-Service und Kafka vertraut sind und Oracle SQL-Zugriff auf Kafka mit dem Stream-Service verwenden möchten, können Sie direkt zu "Oracle Cloud Infrastructure Streaming-Cluster für Oracle SQL-Zugriff auf Kafka-Schritt 2.1 einrichten" springen. Führen Sie je nach Bedarf den Rest des Tutorials durch.

Voraussetzungen

OCI-Account oder -Mandant mit Autorisierung zum Erstellen und Verwenden des Stream-Service.
Apache Kafka-Cluster 0.10.2 oder höher. Der Stream-Service erfüllt diese Anforderung.
Oracle Database 12.2 oder höher, in der Oracle SQL-Zugriff auf Kafka installiert wird (Version 19c wird in diesem Tutorial verwendet). Wir verwenden Oracle Linux als Plattform-BS für Oracle Database. Anweisungen nach und nach bleiben für andere Plattformen gleich.
Java 8 oder höher auf dem Oracle Database-Host installiert.

Oracle Cloud Infrastructure Streaming und Oracle SQL-Zugriff auf Kafka-Integration

Streampool und -stream in Oracle Cloud Infrastructure erstellen

Melden Sie sich bei Ihrem OCI-Account/-Mandanten an, und richten Sie einen Streampool des Streamservice namens StreampoolForOsak und den Stream mit dem Namen StreamForOsak wie folgt ein.
Jetzt erstellen wir einen Stream namens StreamForOsak im gerade erstellten Streampool StreampoolForOsak.

Für diese Ressourcenerstellung können Sie eines der vorhandenen Compartments verwenden. Der Einfachheit halber haben wir ein neues Compartment namens OssOsakIntegration erstellt. Alle Ressourcen befinden sich im selben Compartment.

In der Stream-Serviceterminologie werden Kafka-Themen als Streams bezeichnet. Aus dem Oracle SQL-Zugriff auf den Kafka-Punkt ist der Stream StreamForOsak also ein Kafka-Thema mit drei Partitionen.

Jetzt sind wir mit der Stream-Servicestream-Erstellung fertig. Danach sind die Begriffe Stream Service und Kafka austauschbar. Gleichermaßen sind die Begriffe "Stream" und "Kafka-Thema" austauschbar.

Benutzer, Gruppen und Policys in Oracle Cloud Infrastructure erstellen

Wenn bereits ein Benutzer mit den richtigen Autorisierungen für die Verwendung des Stream-Service vorhanden ist, kann Schritt 2 vollständig übersprungen werden.

Um die Stream-Servicestreams mit Oracle SQL-Zugriff auf Kafka zu verwenden, müssen wir einen neuen OCI-Benutzer dafür erstellen. Zu diesem Zweck erstellen wir einen neuen Benutzer mit dem Benutzernamen OssOsakUser über die OCI-Webkonsole wie folgt:
Damit Benutzer OssOsakUser sich beim Stream-Service authentifizieren (mit Kafka-APIs), müssen wir wie folgt ein Authentifizierungstoken für diesen neuen Benutzer erstellen:

Nachdem Sie das Token generiert haben, erhalten Sie zuerst und die einzige Möglichkeit, das Authentifizierungstoken zu sehen und zu kopieren. Kopieren Sie daher das Authentifizierungstoken, und bewahren Sie es sicher an einem Ort auf, von dem aus Sie später darauf zugreifen können. Sie benötigen sie in späteren Schritten, insbesondere wenn Sie das Kafka-Cluster für den Oracle SQL-Zugriff auf Kafka konfigurieren. Oracle SQL-Zugriff auf Kafka verwendet diesen Benutzernamen OssOsakUser und sein Authentifizierungstoken für den internen Zugriff auf den Stream-Service mit Kafka Consumer-APIs.
OssOsakUser muss außerdem über die richtigen Berechtigungen in OCI IAM verfügen, um auf das Streamservicecluster zugreifen zu können.

In OCI erhalten Benutzer Berechtigungen mit Hilfe von Policys, die Benutzergruppen zugewiesen sind, zu denen sie gehören. Daher müssen Sie eine Gruppe für OssOsakUser erstellen, gefolgt von einer Policy für diese Gruppe.

Erstellen Sie eine Benutzergruppe wie unten dargestellt:
Fügen Sie den Benutzer OssOsakUser der Benutzergruppe OssOsakUserGroup hinzu.
Um OssOsakUser zur Verwendung des Stream-Servicestreams zu autorisieren, insbesondere Nachrichten daraus zu veröffentlichen und zu lesen, müssen wir die folgende Policy im Mandanten erstellen. Diese Policy erteilt nach der Erstellung allen Benutzern in der Gruppe OssOsakUserGroup Berechtigungen. Da sich der Benutzer OssOsakUser in derselben Gruppe befindet, erhält er dieselben Berechtigungen.

Text-Snippet für dieselbe oben genannte Policy:
```
Allow group OssOsakUserGroup to manage streams in compartment OssOsakIntegration  
Allow group OssOsakUserGroup to manage stream-push in compartment OssOsakIntegration   
Allow group OssOsakUserGroup to manage stream-pull in compartment OssOsakIntegration  
Allow group OssOsakUserGroup to manage stream-family in compartment OssOsakIntegration
```

Oracle SQL-Zugriff auf Kafka auf einem Oracle Database-Host installieren

Der Oracle SQL-Zugriff auf Kafka-Kit ist als Teil eines häufig verwendeten SQL Developer-Service verfügbar.

Verwenden Sie den offiziellen SQL Developer-Link, um die neueste Version von SQL Developer herunterzuladen. Zum Schreiben dieses Tutorials ist die neueste SQL Developer-Version 20.4.

Laden Sie Oracle SQL Developer für dieselbe Plattform wie den Oracle Database-Host herunter. In unserer Entwicklungsbox laden wir Oracle SQL Developer for Oracle Linux RPM herunter (wie die Oracle Database auf Oracle Linux Platform ausgeführt wird).

Nachdem der Download abgeschlossen ist, extrahieren Sie den Inhalt der RPM-/ZIP-Datei von Oracle SQL Developer mit dem Befehl unzip oder tar in ein beliebiges Verzeichnis/einen beliebigen Ordner.
```
tar xvf sqldeveloper-20.4.0.379.2205-20.4.0-379.2205.noarch.rpm
```
Gehen Sie zu dem Verzeichnis, in dem Oracle SQL Developer-Inhalte extrahiert wurden, und suchen Sie den Oracle SQL-Zugriff auf die Kafka-ZIP-Datei orakafka.zip wie folgt:
```
$ find . -name 'orakafta*'  
./sqldeveloper/orakafta  
./sqldeveloper/orakafta/orakafta.zip
```
Der Oracle SQL-Zugriff auf Kafka-Kit befindet sich in der Datei orakafka.zip. Wir interessieren uns nicht für den Rest des Inhalts des SQL-Entwicklers für diese Demo. Was die Installation und Verwendung des Oracle SQL-Zugriffs auf Kafka betrifft, ist orakafka.zip alles, was wir brauchen.
Kopieren Sie die Datei orakafka.zip mit dem Befehl scp oder GUI-basierten FTP-Clients wie FileZilla auf den Oracle Database-Host.

Stellen Sie eine SSH-Verbindung zum Oracle Database-Knoten her, und verschieben Sie orakafka.zip mit mv_ command in /home/oracle(Home-Verzeichnis des Benutzers oracle).

Um die übrigen Anweisungen zur Installation des Oracle SQL-Zugriffs auf Kafka zu erhalten, müssen Sie auf dem Oracle Database-Host zu dem Benutzer oracle wechseln.

Stellen Sie sicher, dass das aktuelle Arbeitsverzeichnis /home/oracle ist. orakafka.zip befindet sich bereits im selben Verzeichnis.

[opc@dbass ~]$ sudo su - oracle  
Last login: Sat Feb 20 09:31:12 UTC 2021  
[oracle@dbass ~]$ pwd  
/home/oracle  
[oracle@dbass ~]$ ls -al  
total 3968  
drwx------ 6 oracle oinstall    4096 Feb 19 17:39 .  
drwxr-xr-x 5 root   root        4096 Feb 18 15:15 ..  
-rw------- 1 oracle oinstall    4397 Feb 20 09:31 .bash_history  
-rw-r--r-- 1 oracle oinstall      18 Nov 22  2019 .bash_logout  
-rw-r--r-- 1 oracle oinstall     203 Feb 18 15:15 .bash_profile  
-rw-r--r-- 1 oracle oinstall     545 Feb 18 15:20 .bashrc  
-rw-r--r-- 1 oracle oinstall     172 Apr  1  2020 .kshrc  
drwxr----- 3 oracle oinstall    4096 Feb 19 17:37 .pki  
drwxr-xr-x 2 oracle oinstall    4096 Feb 18 15:20 .ssh  
-rw-r--r-- 1 oracle oinstall 4002875 Feb 19 17:38 orakafka.zip

Extrahieren oder dekomprimieren Sie orakafka.zip. Dadurch wird ein neues Verzeichnis namens orakafka-<version> mit dem extrahierten Inhalt erstellt. In unserem Fall lautet der Wert orakafka-1.2.0 wie folgt:
```
[oracle@dbass ~]$ unzip orakafka.zip  
Archive:  orakafka.zip 
creating: orakafka-1.2.0/  
```

Extrahieren: orakafka-1.2.0/kit_version.txt
Auflösen: orakafka-1.2.0/orakafka_distro_install.sh
Extrahieren: orakafka-1.2.0/orakafka.zip
Auflösen: orakafka-1.2.0/README

6. Now we follow the instructions found in the _**orakafka-1.2.0/README**_ for the setup of Oracle SQL access to Kafka. We follow _simple install_ for single-instance Oracle Database. 

This README doc has instructions for Oracle SQL access to Kafka installation on Oracle Real Application Clusters (Oracle RAC) as well. By and large, in the case of Oracle RAC, we need to replicate the following steps on all nodes of Oracle RAC. Please follow the README for details.

[oracle@dbass ~]$ cd orakafka-1.2.0/
[oracle@dbass orakafka-1.2.0]$ ls -al
total 3944
drwxrwxr-x 2 oracle oinstall 4096 Feb 20 09:12 .
drwx—— 6 oracle oinstall 4096 Feb 19 17:39 ..
-rw-r–r– 1 oracle oinstall 6771 Oct 16 03:11 README
-rw-r–r– 1 oracle oinstall 5 Oct 16 03:11 kit_version.txt
-rw-rw-r– 1 oracle oinstall 3996158 Oct 16 03:11 orakafka.zip
-rwxr-xr-x 1 oracle oinstall 17599 Oct 16 03:11 orakafka_distro_install.sh

tar xvf sqldeveloper-20.4.0.379.2205-20.4.0-379.2205.noarch.rpm

7. As per _./orakafka-1.2.0/README_, we install Oracle SQL access to Kafka on the Oracle Database host with the help of _./orakafka-1.2.0/orakafka\_distro\_install.sh_ script. Argument -p lets us specify the location or base directory for the Oracle SQL access to Kafka installation on this host. 

   We choose the newly created empty directory named ora\_kafka\_home as the OSaK base directory on this host. So the full path of the OSaK base directory will be _/home/oracle/ora\_kafka\_home_.

[oracle@dbass ~]$ ./orakafka-1.2.0/orakafka_distro_install.sh -p ./ora_kafka_home/

Step Create Product Home::
————————————————————–
…../home/oracle/ora_kafka_home already exists..
Step Create Product Home: completed.
PRODUCT_HOME=/home/oracle/ora_kafka_home

Step Create app_data home::
————————————————————–
….. creating /home/oracle/ora_kafka_home/app_data and subdirectories
……Generated CONF_KIT_HOME_SCRIPT=/home/oracle/ora_kafka_home/app_data/scripts/configure_kit_home.sh
……Generated CONF_APP_DATA_HOME_SCRIPT=/home/oracle/ora_kafka_home/configure_app_data_home.sh
Step Create app_data home: completed.
APP_DATA_HOME=/home/oracle/ora_kafka_home/app_data

Step unzip_kit::
————————————————————–
…..checking for existing binaries in /home/oracle/ora_kafka_home/orakafka
…..unzip kit into /home/oracle/ora_kafka_home/orakafka
Archive: /home/oracle/orakafka-1.2.0/orakafka.zip
creating: /home/oracle/ora_kafka_home/orakafka/
extracting: /home/oracle/ora_kafka_home/orakafka/kit_version.txt
inflating: /home/oracle/ora_kafka_home/orakafka/README
creating: /home/oracle/ora_kafka_home/orakafka/doc/
inflating: /home/oracle/ora_kafka_home/orakafka/doc/README_INSTALL
creating: /home/oracle/ora_kafka_home/orakafka/jlib/
inflating: /home/oracle/ora_kafka_home/orakafka/jlib/osakafka.jar
inflating: /home/oracle/ora_kafka_home/orakafka/jlib/kafka-clients-2.5.0.jar
inflating: /home/oracle/ora_kafka_home/orakafka/jlib/slf4j-simple-1.7.28.jar
inflating: /home/oracle/ora_kafka_home/orakafka/jlib/lz4-java-no-jni-1.7.1.jar
inflating: /home/oracle/ora_kafka_home/orakafka/jlib/snappy-java-no-jni-1.1.7.3.jar
inflating: /home/oracle/ora_kafka_home/orakafka/jlib/zstd-no-jni-1.4.4-7.jar
inflating: /home/oracle/ora_kafka_home/orakafka/jlib/slf4j-api-1.7.30.jar
creating: /home/oracle/ora_kafka_home/orakafka/bin/
inflating: /home/oracle/ora_kafka_home/orakafka/bin/orakafka_stream.sh
inflating: /home/oracle/ora_kafka_home/orakafka/bin/orakafka.sh
creating: /home/oracle/ora_kafka_home/orakafka/bin/scripts/
inflating: /home/oracle/ora_kafka_home/orakafka/bin/scripts/removeuser_cluster.sh
inflating: /home/oracle/ora_kafka_home/orakafka/bin/scripts/setup_all.sh
inflating: /home/oracle/ora_kafka_home/orakafka/bin/scripts/remove_cluster.sh
inflating: /home/oracle/ora_kafka_home/orakafka/bin/scripts/verify_install.sh
inflating: /home/oracle/ora_kafka_home/orakafka/bin/scripts/add_cluster.sh
inflating: /home/oracle/ora_kafka_home/orakafka/bin/scripts/config_util.sh
inflating: /home/oracle/ora_kafka_home/orakafka/bin/scripts/test_views.sh
inflating: /home/oracle/ora_kafka_home/orakafka/bin/scripts/install.sh
inflating: /home/oracle/ora_kafka_home/orakafka/bin/scripts/set_java_home.sh
inflating: /home/oracle/ora_kafka_home/orakafka/bin/scripts/list_clusters.sh
inflating: /home/oracle/ora_kafka_home/orakafka/bin/scripts/adduser_cluster.sh
inflating: /home/oracle/ora_kafka_home/orakafka/bin/scripts/uninstall.sh
inflating: /home/oracle/ora_kafka_home/orakafka/bin/scripts/test_cluster.sh
creating: /home/oracle/ora_kafka_home/orakafka/conf/
inflating: /home/oracle/ora_kafka_home/orakafka/conf/orakafka.properties.template
creating: /home/oracle/ora_kafka_home/orakafka/sql/
inflating: /home/oracle/ora_kafka_home/orakafka/sql/orakafkatab.plb
inflating: /home/oracle/ora_kafka_home/orakafka/sql/catnoorakafka.sql
inflating: /home/oracle/ora_kafka_home/orakafka/sql/catorakafka.sql
inflating: /home/oracle/ora_kafka_home/orakafka/sql/pvtorakafkaus.plb
inflating: /home/oracle/ora_kafka_home/orakafka/sql/orakafka_pkg_uninstall.sql
inflating: /home/oracle/ora_kafka_home/orakafka/sql/orakafkab.plb
inflating: /home/oracle/ora_kafka_home/orakafka/sql/pvtorakafkaub.plb
inflating: /home/oracle/ora_kafka_home/orakafka/sql/orakafka_pkg_install.sql
inflating: /home/oracle/ora_kafka_home/orakafka/sql/orakafkas.sql
creating: /home/oracle/ora_kafka_home/orakafka/lib/
inflating: /home/oracle/ora_kafka_home/orakafka/lib/libsnappyjava.so
inflating: /home/oracle/ora_kafka_home/orakafka/lib/libzstd-jni.so
inflating: /home/oracle/ora_kafka_home/orakafka/lib/liblz4-java.so
Step unzip_kit: completed.

Successfully installed orakafka kit in /home/oracle/ora_kafka_home

8. Configure JAVA\_HOME for Oracle SQL access to Kafka. We find the Java path on the node as follows:

[oracle@dbass ~]$ java -XshowSettings:properties -version 2>&1 > /dev/null | grep 'java.home'
java.home = /usr/java/jre1.8.0_271-amd64
[oracle@dbass ~]$ export JAVA_HOME=/usr/java/jre1.8.0_271-amd64

   To set Java home for OSaK, we use the script _/home/oracle/ora\_kafka\_home/orakafka/bin/orakafka.sh_ script, with _set\_java\_home_ option.

[oracle@dbass bin]$ pwd
/home/oracle/ora_kafka_home/orakafka/bin
[oracle@dbass bin]$ ./orakafka.sh set_java_home -p $JAVA_HOME

Step1: Check for valid JAVA_HOME
————————————————————–
Found /usr/java/jre1.8.0_271-amd64/bin/java, JAVA_HOME path is valid.
Step1 succeeded.

Step2: JAVA version check
————————————————————–
java version “1.8.0_271”
Java(TM) SE Runtime Environment (build 1.8.0_271-b09)
Java HotSpot(TM) 64-Bit Server VM (build 25.271-b09, mixed mode)
Java version >= 1.8
Step2 succeeded.

Step3: Creating configure_java.sh script
————————————————————–
Wrote to /home/oracle/ora_kafka_home/app_data/scripts/configure_java.sh
Step3 succeeded.

Successfully configured JAVA_HOME in /home/oracle/ora_kafka_home/app_data/scripts/configure_java.sh

The above information is written to /home/oracle/ora_kafka_home/app_data/logs/set_java_home.log.2021.02.20-04.38.23

[oracle@dbass bin]$

9. Verify installation of OSaK with _verify\_install_ option of script _orakafka.sh_ as follows:

[oracle@dbass ~]$ cd ora_kafka_home/
[oracle@dbass ora_kafka_home]$ cd orakafka/bin/
[oracle@dbass bin]$ ./orakafka.sh verify_install
Prüfen Sie alle Dateien/Tir-Eigentümerrechte - bestanden
Prüfen Sie die Verzeichnisberechtigungen - bestanden
Prüfen Sie die erwarteten ausführbaren Dateien - bestanden

Die obigen Informationen werden in /home/oracle/ora_kafka_home/app_data/logs/verify_install.log.2021.02.19-18.10.15 geschrieben

### Set Up Oracle Cloud Infrastructure Stream Clusters for Oracle SQL Access to Kafka

1. Under _ora\_kafka\_home_, that is _/home/oracle/ora\_kafka\_home_, we have two more READMEs as follows:

[oracle@dbass ~]$ find ora_kafka_home/ -name "README*"
ora_kafka_home/orakafka/README
ora_kafka_home/orakafka/doc/README_INSTALL

   _~/ora\_kafka\_home/orakafka/README_ is the readme for this release of OSaK that we have installed. Please read through this readme.

   And _ora\_kafka\_home/orakafka/doc/README\_INSTALL_ is the README for the actual setup of a Kafka cluster for Oracle SQL access to Kafka. The rest of the steps 2 onwards below follow this README by and large. As per the same, we will leverage _~/ora\_kafka\_home/orakafka/bin/orakafka.s_h script, for adding a Kafka cluster, adding an Oracle Database user for using the Kafka cluster in the next steps.

2. Add our Stream service stream pool to Oracle SQL access to Kafka.

   As mentioned earlier, from the Oracle SQL access to Kafka point of view, the Stream service stream pool is a Kafka cluster.

   We use the _add\_cluster_ option of the _orakafka.sh_ script to add the cluster to OSaK. We use the _\-c_ argument to name the cluster as _kc1_.

[oracle@dbass bin]$ pwd
/home/oracle/ora_kafka_home/orakafka/bin
[oracle@dbass bin]$ ./orakafka.sh add_cluster -c kc1

Step1: Erstellung des Konfigurationsverzeichnisses für Dateisystemcluster
---------------------
Erstellen des Dateisystemclusterverzeichnisses abgeschlossen.
Konfigurieren Sie Sicherheitseigenschaften unter /home/oracle/ora_kafka_home/app_data/clusters/KC1/conf/orakafka.properties.
Step1 erfolgreich.

Step2: DDL zum Erstellen des DB-Verzeichnisses der Clusterkonfiguration generieren
---------------------
Führen Sie das folgende SQL-Skript aus, während Sie als sysdba angemeldet sind
, um das Verzeichnis der Clusterkonfigurationsdatenbank zu erstellen:
@/home/oracle/ora_kafka_home/app_data/scratch/orakafka_create_KC1_CONF_DIR.sql
Step2 erfolgreich generiertes Skript.

****SUMMARY*****

TODO-Aufgaben:

Sicherheitseigenschaften unter /home/oracle/ora_kafka_home/app_data/clusters/KC1/conf/orakafka.properties konfigurieren
Führen Sie die folgende SQL aus, während Sie als sysdba angemeldet sind:
@/home/oracle/ora_kafka_home/app_data/scratch/orakafka_create_KC1_CONF_DIR.sql

Die obigen Informationen werden in /home/oracle/ora_kafka_home/app_data/logs/add_cluster.log.2021.02.20-05.23.30 geschrieben.

[oracle@dbass bin]$

   We get two TODO tasks as per output from the above execution of the _add\_cluster_ command. 

   1. For the first task, we add security properties for our Stream service stream to `/home/oracle/ora_kafka_home/app_data/clusters/KC1/conf/orakafka.properties`. 

      Where to get Kafka-compatible security configs for the Stream service cluster also known as (AKA) streampool? We get these security configs from the OCI web console as shown below.

      Please take note of the bootstrap server endpoint(_cell-1.streaming.ap-mumbai-1.oci.oraclecloud.com:9092_ from the screenshot below) as well. It is not related to the security configs of the cluster, but we need it in later steps for connecting to our Stream service and Kafka cluster. 

      ![](images/bsend.png " ")

      We write the above config values to OSaK in the following format, to `/home/oracle/ora_kafka_home/app_data/clusters/KC1/conf/orakafka.properties` file using any text editor like say vi. 

      ![](images/osakosssec.png " ")

      For clarity, we have the same configs in text format as follows:

      ```
      security.protocol=SASL_SSL  
      sasl.mechanism=PLAIN  
      sasl.jaas.config=org.apache.kafka.common.security.plain.PlainLoginModule required username="<YOUR_TENANCY_NAME>/<YOUR_OCI_USERID_HERE>/<YOUR_OCI_STREAMPOOL_OCID>" password=" YOUR_AUTH_TOKEN";  
      sasl.plain.username="<YOUR_TENANCY_NAME>/<YOUR_OCI_USERID_HERE>/<YOUR_OCI_STREAMPOOL_OCID>"  
      sasl.plain.password ="YOUR_AUTH_TOKEN";
      ```

      **Note:** default Kafka Consumer Configs are already pre-populated in _orakafka.properties_ for this cluster. If there is a need, one can modify these configs.

   2. For the second TODO task, do SQL script execution as follows: 

      ```
      [oracle@dbass ~]$ sqlplus / as sysdba  
      SQL*Plus: Release 19.0.0.0.0 - Production on Sat Feb 20 05:37:28 2021  
      Version 19.9.0.0.0   
      Copyright (c) 1982, 2020, Oracle.  All rights reserved.
      Connected to:  
      Oracle Database 19c Standard Edition 2 Release 19.0.0.0.0 - Production  
      Version 19.9.0.0.0   
      SQL> alter session set container=p0;  
      Session altered.  
      SQL> @/home/oracle/ora_kafka_home/app_data/scratch/orakafka_create_KC1_CONF_DIR.sql  
      Creating database directory "KC1_CONF_DIR"..  
      Directory created.  
      The above information is written to /home/oracle/ora_kafka_home/app_data/logs/orakafka_create_KC1_CONF_DIR.log  
      Disconnected from Oracle Database 19c Standard Edition 2 Release 19.0.0.0.0 - Production  
      Version 19.9.0.0.0
      ```

      Take note of directory object _KC1\_CONF\_DIR_ created by the above SQL script.

      **Note:** As dictated in add\_cluster output, we run the SQL script as a _SYSDBA_ user, inside the PDB of our interest (_p0_ PDB here).

   3. To make sure that the cluster configuration is working, we can leverage the _test\_cluster_ option of script _orakafka.sh_.

      We pass cluster name with -c argument and bootstrap server with -b argument. We have from bootstrap server info from step 4.2.1.

      ```
      [oracle@dbass bin]$ pwd  
      /home/oracle/ora_kafka_home/orakafka/bin  
      [oracle@dbass bin]$ ./orakafka.sh test_cluster -c kc1 -b cell-1.streaming.ap-mumbai-1.oci.oraclecloud.com:9092  
      Kafka cluster configuration test succeeded.  
         
      Kafka cluster configuration test - "KC1"  
      ------------------------------------------------------  
      KAFKA_BOOTSTRAP_SERVERS=cell-1.streaming.ap-mumbai-1.oci.oraclecloud.com:9092  
      LOCATION_FILE="/home/oracle/ora_kafka_home/app_data/clusters/KC1/logs/orakafka_stream_KC1.loc"  
      ora_kafka_operation=metadata  
      kafka_bootstrap_servers=cell-1.streaming.ap-mumbai-1.oci.oraclecloud.com:9092  
         
      List topics output:  
      StreamForOsak,3  
      ...  
      For full log, please look at /home/oracle/ora_kafka_home/app_data/clusters/KC1/logs/test_KC1.log.2021.02.20-09.01.12  
      Test of Kafka cluster configuration for "KC1" completed.  
         
      The above information is written to /home/oracle/ora_kafka_home/app_data/logs/test_cluster.log.2021.02.20-09.01.12  
         
      [oracle@dbass bin]$
      ```

      As you can see our Kafka cluster configuration test succeeded! We get the list of topics, AKA the Stream service streams in the output here. Topic names are followed by the number of partitions for that stream. Here we have the number of partitions as three, as the Stream service stream StreamForOsak has exactly three partitions.

3. Configure an Oracle Database user for the added Kafka cluster.

   We already have created an Oracle Pluggable Databases (PDB) level Oracle Database user with username books\_admin, for the PDB named _p0_.  We use the _adduser\_cluster_ option to grant required permissions for user books\_admin on Kafka cluster _kc1_. 

[oracle@dbass bin]$ ./orakafka.sh adduser_cluster -c kc1 -u books_admin

   
Step1: Generate DDL to grant permissions on cluster configuration directory to "BOOKS_ADMIN"
--------------------------------------------------------------------------------------------

Execute the following script while connected as sysdba  
to grant permissions on cluster conf directory :  
 @/home/oracle/ora_kafka_home/app_data/scratch/orakafka_adduser_cluster_KC1_user1.sql  
Step1 successfully generated script.  
   
***********SUMMARY************  
   
TODO tasks:  
 
1. Execute the following SQL while connected as sysdba:  
      @/home/oracle/ora_kafka_home/app_data/scratch/orakafka_adduser_cluster_KC1_user1.sql  
      
   The above information is written to /home/oracle/ora_kafka_home/app_data/logs/adduser_cluster.log.2021.02.20-10.45.57  
      
   [oracle@dbass bin]$

Ähnlich wie im vorherigen Schritt muss eine TODO-Aufgabe ausgeführt werden.

Gemäß der Ausgabe ist ein automatisch generiertes SQL-Skript vorhanden. Sie müssen dieses Skript ausführen (als sysdba), um dem Oracle Database-Benutzer books_admin-Berechtigungen für das Clusterkonfigurationsverzeichnis für Cluster kc1 zu erteilen.

In diesem Fall lautet das Verzeichnis /home/oracle/ora_kafka_home/app_data/clusters/KC1.

[oracle@dbass ~]$ sqlplus / as sysdba  
SQL*Plus: Release 19.0.0.0.0 - Production on Sat Feb 20 10:56:17 2021  
Version 19.9.0.0.0  
Copyright (c) 1982, 2020, Oracle.  All rights reserved.  
   
Connected to:  
Oracle Database 19c Standard Edition 2 Release 19.0.0.0.0 - Production  
Version 19.9.0.0.0  
   
SQL> alter session set container=p0;  
Session altered.  
SQL> @/home/oracle/ora_kafka_home/app_data/scratch/orakafka_adduser_cluster_KC1_user1.sql  
   
PL/SQL procedure successfully completed.   
Granting permissions on "KC1_CONF_DIR" to "BOOKS_ADMIN"  
Grant succeeded.`

`The above information is written to /home/oracle/ora_kafka_home/app_data/logs/orakafka_adduser_cluster_KC1_user1.log  
Disconnected from Oracle Database 19c Standard Edition 2 Release 19.0.0.0.0 - Production  
Version 19.9.0.0.0  
[oracle@dbass ~]$

Jetzt verwenden wir die Option install von orakafka.sh. Das übergeordnete Verzeichnis (mit Argument -p) für die Daten dieses Benutzers, die sich auf seine OSaK-Aktivitäten beziehen, wird an die Kafka-Cluster übergeben, denen er hinzugefügt wird.

Mit diesem Befehl werden für uns automatisch zwei DDL-Skripte (Data Definition Language) generiert:

   [oracle@dbass bin]$ ./orakafka.sh install -u books_admin -r /home/oracle/ora_kafka_home/books_admin_user_data_dir  
   
Step1: Creation of filesystem location and default directories  
--------------------------------------------------------------  
Created filesystem location directory at /home/oracle/ora_kafka_home/books_admin_user_data_dir/orakafka_location_dir  
Created filesystem default directory at /home/oracle/ora_kafka_home/books_admin_user_data_dir/orakafka_default_dir  
Step1 succeeded.  
   
Step2: Generate DDL for creation of DB location and default directories  
--------------------------------------------------------------  
Execute the following SQL script while connected as sysdba  
to setup database directories:  
 @/home/oracle/ora_kafka_home/app_data/scratch/setup_db_dirs_user1.sql  
On failure, to cleanup location and default directory setup, please run "./orakafka.sh uninstall -u 'BOOKS_ADMIN'"  
Step2 successfully generated script.  
   
Step3: Install ORA_KAFKA package in "BOOKS_ADMIN" user schema  
--------------------------------------------------------------  
Execute the following script in user schema "BOOKS_ADMIN" to  
install ORA_KAFKA package in the user schema  
 @/home/oracle/ora_kafka_home/app_data/scratch/install_orakafka_user1.sql  
On failure, to cleanup ORA_KAFKA package from user schema, please run "./orakafka.sh uninstall -u 'BOOKS_ADMIN'"  
Step3 successfully generated script.  
   
***********SUMMARY************  
   
TODO tasks:  
   
1. Execute the following SQL while connected as sysdba:  
   @/home/oracle/ora_kafka_home/app_data/scratch/setup_db_dirs_user1.sql  
2. Execute the following SQL in user schema:  
   @/home/oracle/ora_kafka_home/app_data/scratch/install_orakafka_user1.sql  
   
The above information is written to /home/oracle/ora_kafka_home/app_data/logs/install.log.2021.02.20-11.33.09  
   
[oracle@dbass bin]

Die erste Aufgabe besteht darin, ein SQL-Skript auszuführen, um die beiden Verzeichnisse /home/oracle/ora_kafka_home/books_admin_user_data_dir/orakafka_location_dir und /home/oracle/ora_kafka_home/books_admin_user_data_dir/orakafka_default_dir
bei Oracle DB als Directory-Objekte zu registrieren.

Wie in der Ausgabe vorgeschrieben, müssen Sie sie wie folgt mit SYSDBA-Berechtigungen ausführen:

   [oracle@dbass ~]$ sqlplus / as sysdba  
SQL*Plus: Release 19.0.0.0.0 - Production on Sat Feb 20 11:46:04 2021  
Version 19.9.0.0.0  
Copyright (c) 1982, 2020, Oracle.  All rights reserved.  
Connected to:  
Oracle Database 19c Standard Edition 2 Release 19.0.0.0.0 - Production  
Version 19.9.0.0.0  
   
SQL> alter session set container=p0;  
   
Session altered.  
   
SQL> @/home/oracle/ora_kafka_home/app_data/scratch/setup_db_dirs_user1.sql  
Checking if user exists..  
   
PL/SQL procedure successfully completed.  
Creating location and default directories..  
PL/SQL procedure successfully completed.  
Directory created.  
Directory created.  
Grant succeeded.  
Grant succeeded.  
Creation of location dir "BOOKS_ADMIN_KAFKA_LOC_DIR" and default dir "BOOKS_ADMIN_KAFKA_DEF_DIR" completed.  
Grant of required permissions on "BOOKS_ADMIN_KAFKA_LOC_DIR","BOOKS_ADMIN_KAFKA_DEF_DIR" to "BOOKS_ADMIN" completed.  
The above information is written to /home/oracle/ora_kafka_home/app_data/logs/setup_db_dirs_user1.log  
Disconnected from Oracle Database 19c Standard Edition 2 Release 19.0.0.0.0 - Production  
Version 19.9.0.0.0  
[oracle@dbass ~]$

Notieren Sie sich die Directory-Objekte, die von den obigen SQL-Skripten BOOKS_ADMIN_KAFKA_LOC_DIR und BOOKS_ADMIN_KAFKA_DEF_DIR erstellt wurden.

Jetzt gehen wir zur zweiten TODO-Aufgabe.

Hier wird ein weiteres SQL-Skript als books_admin (und nicht als sysdba) auf der PDB p0 ausgeführt. Dieses Skript installiert den Oracle SQL-Zugriff auf das Kafka-Package und die Objekte in dem Schema, das zu books_admin gehört.

   [oracle@dbass ~]$ sqlplus books_admin@p0pdb #p0pdb is tns entry for p0 pdb  
SQL*Plus: Release 19.0.0.0.0 - Production on Sat Feb 20 11:52:33 2021  
Version 19.9.0.0.0  
Copyright (c) 1982, 2020, Oracle.  All rights reserved.  
Enter password:  
Last Successful login time: Fri Feb 19 2021 14:04:59 +00:00  
Connected to:  
Oracle Database 19c Standard Edition 2 Release 19.0.0.0.0 - Production  
Version 19.9.0.0.0  
   
SQL> ALTER SESSION SET CONTAINER=p0;  
Session altered.  
   
SQL> @/home/oracle/ora_kafka_home/app_data/scratch/install_orakafka_user1.sql  
Verifying user schema..  
   
PL/SQL procedure successfully completed.  
   
Verifying that location and default directories are accessible..  
   
PL/SQL procedure successfully completed.  
   
Installing ORA_KAFKA package in user schema..  
.. Creating ORA_KAFKA artifacts  
   
Table created.  
Table created.  
Table created.  
Table created.  
Package created.  
No errors.  
Package created.  
No errors.  
Package body created.  
No errors.  
Package body created.  
No errors.  
The above information is written to /home/oracle/ora_kafka_home/app_data/logs/install_orakafka_user1.log  
Disconnected from Oracle Database 19c Standard Edition 2 Release 19.0.0.0.0 - Production  
Version 19.9.0.0.0  
[oracle@dbass ~]$

Stream Service Cluster bei Oracle Database registrieren und Views für den Stream erstellen

In diesem Schritt wird das Cluster kc1 mit Oracle Database erstellt und Ansichten für den Stream StreamForOsak erstellt.

Alle SQL-Abfragen für diesen Schritt müssen als Benutzer books_admin und in der p0-PDB ausgeführt werden.

Registrieren Sie das Cluster mit Oracle SQL-Zugriff auf die Kafka-Prozedur ORA_KAFKA.REGISTER_CLUSTER.

BEGIN  
ORA_KAFKA.REGISTER_CLUSTER  
('kc1', -- cluster name  
'cell-1.streaming.ap-mumbai-1.oci.oraclecloud.com:9092', -- fill up your bootstrap server here   
'BOOKS_ADMIN_KAFKA_DEF_DIR', -- default directory for external table created in previous steps  
'BOOKS_ADMIN_KAFKA_LOC_DIR', -- this directory object too is created in previous steps  
'KC1_CONF_DIR', --config dir for cluster  
'Registering kc1 for this session'); --description   
END;  
/

Erstellen Sie eine Oracle Database-Tabelle namens BOOKS, die dasselbe Schema wie Nachrichten in unserem Kafka-Topic haben muss StreamForOsak.

CREATE TABLE BOOKS ( -- reference table. It is empty table. Schema of this table must correspond to Kafka Messages  
id int,  
title varchar2(50),  
author_name varchar2(50),  
author_email varchar2(50),  
publisher varchar2(50)  
);  
/

Erstellen Sie wie folgt eine Ansicht für unser Thema StreamForOsak mit der Stored Procedure "Hilfe" aus dem Oracle SQL-Zugriff auf Kafka-Package viz CREATE_VIEWS.

DECLARE  
 application_id VARCHAR2(128);  
 views_created INTEGER;  
BEGIN  
ORA_KAFKA.CREATE_VIEWS  
('kc1', -- cluster name  
'OsakApp0', -- consumer group name that OSS or Kafka cluster sees.  
'StreamForOsak', -- Kafka topic aka OSS stream name  
'CSV', -- format type  
'BOOKS', -- database reference table  
views_created, -- output  
application_id); --output  
dbms_output.put_line('views created  = ' || views_created);  
dbms_output.put_line('application id = ' || application_id);  
END;  
/

Der Oracle SQL-Zugriff auf Kafka unterstützt zwei Formate für Kafka-Nachrichten, CSV und JSON. Hier verwenden wir CSV. Ein Beispiel für eine Kafka-Nachricht, die dem BOOKS-Tabellenschema entspricht, ist also 101, Famous Book, John Smith, john@smith.com, First Software.


tar xvf sqldeveloper-20.4.0.379.2205-20.4.0-379.2205.noarch.rpm

Im obigen Schritt wird eine Ansicht für jede Partition des Themas erstellt. Da das Thema StreamForOsak drei Partitionen enthält, gibt es drei Ansichten. Der Name jeder Ansicht hat das Format KV_<CLUSTER_NAME>_<GROUP_NAME>_TOPIC_<NUM_OF_PARTITION>.

Hier gibt es drei Ansichten, wie unten dargestellt, eine für jede Partition.

Die View KV_KC1_OSAKAPP0_STREAMFOROSAK_0 ist also Partition 0 zugeordnet, die View KV_KC1_OSAKAPP0_STREAMFOROSAK_2 ist Partition 1 zugeordnet und zuletzt KV_KC1_OSAKAPP0_STREAMFOROSAK_0 ist Partition 2 des Themas StreamForOsak zugeordnet.

Daten in den Stream erzeugen

Erstellen Sie eine Testnachricht, um StreamForOsak mit der Schaltfläche Testnachricht erzeugen in der Oracle Cloud Infrastructure-(OCI-)Webkonsole zu streamen, wie unten dargestellt.

Wenn Sie auf Testnachricht erzeugen klicken, wird ein Fenster mit einem Feld zur Eingabe der Testnachricht angezeigt, wie unten dargestellt.

Die folgende Meldung wird angezeigt:

200, Andrew Miller Part 1, MS Brown, mb@example.com, First Software

Unnötig zu sagen, hätten wir auch die Standard-Kafka-Producer-API in Java/Python oder OCI-SDK für den Stream-Service verwenden können, um die Nachricht an den Stream-Servicestream zu erzeugen.

Nachdem Sie im obigen Fenster auf Erzeugen geklickt haben, veröffentlichen wir die Nachricht im Stream StreamForOsak. Mit dem Dienstprogramm Load Message können Sie die Partition anzeigen, wo unsere Nachricht gelandet ist.

Wie oben dargestellt, wird die Nachricht in Partition 2 des Themas StreamForOsak gelandet.

Streamservicemeldungen mit den Datenbankansichten abrufen, die von Oracle SQL-Zugriff auf gespeicherte Kafka-Prozeduren eingerichtet wurden

Sie können eine einfache SQL-Abfrage ausführen:


SELECT * FROM KV_KC1_OSAKAPP0_STREAMFOROSAK_2_

Wie unten gezeigt, können Sie einfach den View-SQL-Entwickler öffnen, um die Daten in der Ansicht KV_KC1_OSAKAPP0_STREAMFOROSAK_2 anzuzeigen:

Wir haben die Ansicht KV_KC1_OSAKAPP0_STREAMFOROSAK_2 ausgewählt, wie sie Partition 2 des Streams StreamForOsak entspricht. Jedes Mal, wenn die SELECT SQL-Abfrage für diese View ausgeführt wird, wird sie zur entsprechenden Partition des zugehörigen Themas geleitet und ruft neue nicht festgeschriebene Nachrichten (für die Nutzungsgruppe OsakApp0) als Zeilen in der View ab. Jede Nachricht erhält eine eigene Zeile in der Ansicht. Beachten Sie, dass Daten dieser Ansichten nicht dauerhaft gespeichert werden.

Neugierige Augen können auch beobachten, dass Oracle SQL-Zugriff auf Kafka Metadateninformationen wie den Offset der Nachricht, ihre Partition und den Zeitstempel in zusätzlichen Spalten abruft und speichert.

Wahrscheinlich möchten Sie diese View immer wieder abfragen. Für jede Ausführung der Abfrage soll die View sequenziell im Stream verschoben werden. Dies lässt sich mit dem folgenden kanonischen Code-Snippet problemlos erreichen:

LOOP
ORA_KAFKA.NEXT_OFFSET(‘_KV_KC1_OSAKAPP0_STREAMFOROSAK_2_’);

SELECT * FROM KV_KC1_OSAKAPP0_STREAMFOROSAK_2_;

ORA_KAFKA.UPDATE_OFFSET(‘_KV_KC1_OSAKAPP0_STREAMFOROSAK_2_’);

COMMIT;
END LOOP;

Wie bereits erwähnt, werden bei Verwendung des Oracle SQL-Zugriffs auf Kafka Stream-Offsets von Oracle Database und nicht vom Stream-Service verwaltet. Sie leben in Systemtabellen, die das Positionieren von Offsets für alle Partitionen verfolgen, auf die über die Ansicht KV_KC1_OSAKAPP0_STREAMFOROSAK_2 zugegriffen wird.

Der NEXT_OFFSET-Aufruf bindet die KV_KC1_OSAKAPP0_STREAMFOROSAK_2-Ansicht einfach an ein neues Set von Offsets, die neue Daten darstellen, die in der Oracle Cloud Infrastructure Streaming-Partition gespeichert sind, auf die von der View zugegriffen wird. UPDATE_OFFSET gibt an, wie viele Zeilen für jede Partition gelesen wurden, und überträgt die Offsets an neue Positionen.

Das COMMIT garantiert, dass diese Arbeitseinheit ACID-konform ist.

Schlussfolgerung

In diesem Tutorial konzentrieren wir uns darauf, wie wir Oracle SQL-Zugriff auf Kafka installieren und mit dem Stream-Service verwenden können. Da der Stream-Service Kafka-kompatibel ist, entspricht er einem Kafka-Cluster für den Oracle SQL-Zugriff auf Kafka.

Beachten Sie, dass die Oberfläche so wenig wie möglich gekratzt wurde, was die Funktionalität von Oracle SQL-Zugriff auf Kafka betrifft. Oracle SQL-Zugriff auf Kafka ist sehr konfigurierbar. Im Gegensatz zu den Views können sogar Streamingdaten in Oracle Database-Tabellen gespeichert werden, die auf dem Datenträger persistiert werden. Weitere Informationen finden Sie in den README-Dateien, die im Oracle SQL-Zugriff auf die Kafka-Installation bereitgestellt sind, und in den nachfolgenden Referenzen.

Danksagungen

Autor - Mayur Raleraskar, Solutions Architect

```

Weitere Lernressourcen

Sehen Sie sich andere Übungen zu docs.oracle.com/learn an, oder greifen Sie auf weitere Inhalte für kostenloses Lernen im Oracle Learning YouTube-Kanal zu. Außerdem besuchen Sie education.oracle.com/learning-explorer, um Oracle Learning Explorer zu werden.

Produktdokumentation finden Sie im Oracle Help Center.

Titel und Copyright-Informationen

Stream analytics using Oracle Cloud Infrastructure Streaming and Oracle Database

F50464-01

November 2021