Richten Sie Data Flow ein, um Ihre On-Premise-Logs in Oracle Cloud Infrastructure zu verarbeiten

Einführung

In diesem Tutorial stellen Sie die Cloud-Infrastruktur bereit und stellen den PySpark-Code für das automatische Hochladen, Verarbeiten und Speichern von On-Premise-Logdaten in der Cloud bereit. Die Daten werden in Object Storage bereitgestellt, in Data Flow verarbeitet und zur Analyse in Autonomous Data Warehouse gespeichert.

Das folgende Diagramm zeigt die Architektur:

Beschreibung der Abbildung architektur-analyze-logs.png

Sie erstellen die PySpark-App und stellen Oracle Cloud Infrastructure (OCI) dann mit einem Terraform-Skript bereit, das für diesen Zweck konzipiert ist. Sie laden das Skript aus dem GitHub-Repository von Oracle herunter und nehmen kleinere Änderungen vor, um einige Variablenwerte zu aktualisieren. Anschließend wenden Sie das Terraform-Skript an.

Ziele

Nach Abschluss dieses Tutorials verfügen Sie über ein Arbeitssystem, das Daten aus Object Storage aufnimmt, diese mit einer PySpark-App in Data Flow verarbeitet und die Ergebnisse in Autonomous Data Warehouse speichert.

Die hier bereitgestellte PySpark-App zeigt, wie Sie Ihre Workloads authentifizieren und sichern und wie Sie sie für das Einfügen in die Datenbank vorbereiten. Sie müssen sie an Ihre spezifischen Anforderungen an die Datenverarbeitung anpassen.

Voraussetzungen

Bevor Sie dieses Tutorial starten, müssen Sie das Tutorial Data Flow PySpark-Apps mit Autonomous Database in Oracle Cloud Infrastructure verbinden ausführen. In diesem Tutorial erfahren Sie, wie Sie ein Abhängigkeitsarchiv erstellen, das die für dieses Tutorial erforderlichen Python- und Java-Librarys enthält. Insbesondere benötigen Sie die Datei archive.zip aus diesem Tutorial.

Um dieses Tutorial abzuschließen, benötigen Sie Zugriff auf einen Mandanten auf Oracle Cloud Infrastructure mit Berechtigungen zum Erstellen der Artefakte, die im Architekturdiagramm angezeigt werden.

In diesem Tutorial laden Sie den Terraform-Code herunter, der die Artefakte erstellt, wie im Architekturdiagramm beschrieben. Der Code befindet sich in einem Repository auf GitHub. Sie können den Terraform-Code auf Ihrer lokalen Entwicklungsmaschine ausführen oder über die Cloud-Shell in Oracle Cloud Infrastructure ausführen. In Cloud Shell sind Terraform und Git installiert.

Wenn Sie Ihren lokalen Rechner verwenden, gelten die folgenden Voraussetzungen:

Git auf Ihrem Entwicklungscomputer installiert. Damit wird das Terraform-Code-Repository geklont.
Terraform wird auf Ihrem Entwicklungscomputer installiert. Hiermit erstellen Sie die Infrastruktur auf OCI.
Eine Netzwerkverbindung zu Ihrem OCI-Mandanten.

ADW-Verbindungsdetails

Um eine Verbindung zu einer ADW-Datenbank herzustellen, müssen Sie ein Wallet als Teil der Verbindungsparameter übergeben. Das Wallet enthält Zugangsdaten und weitere Details, mit denen der Bearbeiter eine Verbindung zur Datenbank herstellen kann. Der Dateiname des Wallets hat im Allgemeinen die Form wallet_<database-name>.zip, könnte jedoch einen anderen Namen haben. Mit dem Wallet erhalten Sie eine Verbindung zur Datenbank, Ihre Datenbankberechtigungen werden jedoch durch den Benutzernamen und das Kennwort der Datenbank bestimmt.

Das Terraform zu diesem Tutorial erstellt eine Autonomous Data Warehouse-Datenbank vom Typ "Immer kostenlos" mit dem Namen Logs. Das Wallet für die Datenbank wird an zwei Stellen gespeichert. Ein Bucket befindet sich in Object Storage mit dem Namen Wallet. Der andere befindet sich im Verzeichnis auf dem Rechner, in dem Sie den Terraform-Code ausgeführt haben. In beiden Fällen lautet der Name der Wallet-Datei wallet_logs.zip.

Terraform generiert das ADMIN-Kennwort, wenn es die Datenbank erstellt, und zeigt es Ihnen an, wenn es abgeschlossen ist.

Oracle Cloud Infrastructure-Umgebung vorbereiten

Bevor Sie die PySpark-App erstellen und Terraform ausführen, müssen Sie eine vorläufige Konfiguration Ihres OCI-Mandanten vornehmen.

Sie müssen ein Compartment und eine Benutzergruppe erstellen, die für Ihre Data Flow-App dediziert ist. So können Sie Data Flow von anderen Benutzern im Mandanten isolieren.

Terraform kann das Compartment und die Gruppen erstellen. In diesem Tutorial erstellen Sie sie jedoch selbst. Dadurch lernen Sie, wie Sie die OCI-Konsole navigieren und verwenden.

Erstellen Sie ein Compartment

Erstellen Sie ein Compartment, das ausschließlich zur Aufnahme der Artefakte, der Konfiguration und anderer Ressourcen verwendet wird, die sich auf die Pipeline beziehen.

Melden Sie sich als Benutzer mit Administratorberechtigungen bei der Oracle Cloud Infrastructure-Konsole an.
Wählen Sie im Navigationsmenü der Konsole die Option Identität aus, und klicken Sie auf Compartment.
Klicken Sie auf Compartment erstellen.
Geben Sie Dataflow als Namen des neuen Compartments ein, geben Sie eine geeignete Beschreibung ein, und stellen Sie sicher, dass Übergeordnetes Compartment Ihr Root Compartment ist.
Klicken Sie auf Compartment erstellen.
Nachdem das Compartment erstellt wurde, erstellen Sie einen Datensatz seiner OCID. Sie benötigen die OCID später, wenn Sie die Datei terraform.tfvars ändern.

Gruppen erstellen

Sie müssen zwei Gruppen erstellen. Eine Gruppe enthält Benutzer, die Data Flow verwalten können. Die andere Gruppe enthält Benutzer, die Data Flow verwenden können, jedoch nicht verwalten dürfen.

Gruppe erstellen.
1. Wählen Sie im Navigationsmenü der Konsole Identität aus, und klicken Sie auf Gruppen.
2. Klicken Sie auf Gruppe erstellen.
3. Geben Sie Dataflow_Admin_Group als Namen der Gruppe ein, geben Sie eine geeignete Beschreibung ein, und klicken Sie auf Erstellen.
Wiederholen Sie den vorherigen Schritt, um eine weitere Gruppe namens Dataflow_User_Group zu erstellen.
Fügen Sie Ihren Benutzer zu Dataflow_Admin_Group hinzu. Klicken Sie auf Dataflow_Admin_Group und dann auf Benutzer zu Gruppe hinzufügen, und wählen Sie Ihren Benutzer aus der Liste aus.

Notieren Sie sich Ihren Object Storage-Namespace

Klicken Sie auf das Benutzerprofilsymbol, und klicken Sie im geöffneten Menü auf den Mandantennamen.
Suchen Sie auf der geöffneten Seite den Wert für Object Storage-Namespace, und kopieren Sie ihn, um ihn später zu verwenden.

API-Schlüssel generieren

Terraform verwendet die OCI-API, um Infrastruktur in OCI zu erstellen und zu verwalten. Dazu müssen Public Key und Fingerprint eines API-Schlüsselpaares vorhanden sein.

So generieren Sie Ihr eigenes Public/Private-Key-Paar:

Klicken Sie auf Ihr Benutzerprofilsymbol und im daraufhin geöffneten Menü auf Benutzereinstellungen.
Prüfen Sie auf der Seite "Benutzerdetails" im Abschnitt "Ressourcen", und klicken Sie auf API-Schlüssel.
Klicken Sie auf API-Schlüssel hinzufügen.
Klicken Sie im geöffneten Bereich "API-Schlüssel hinzufügen" auf Private Key herunterladen.
Kopieren Sie in der Vorschau der Konfigurationsdatei den Inhalt des Textfelds, und speichern Sie ihn an einem geeigneten Speicherort. Sie benötigen diese Informationen später beim Einrichten von Terraform.
Klicken Sie auf Schließen.
Benennen Sie die heruntergeladene Private-Key-Datei um. Verwenden Sie einen einfachen Namen wie oci_api_key.pem.

Datenbank-Admin-Kennwort zu Vault hinzufügen

Sie müssen ein Vault Secret für das ADMIN-Kennwort der Datenbank erstellen und die OCID aufzeichnen. Dazu benötigen Sie die PASSWORD_SECRET_OCID-Konstante in der PySpark-App, die Sie später erstellen.

For now, enter a fake password into the vault secret. This is because you don’t yet know what the password is. You won’t know the password until after the Terraform completes. But you need the OCID of the secret for the PySpark app that the Terraform uploads to Object Storage. So first you create a secret, record its OCID, then after the Terraform completes, you update the secret with the real password.

Gehen Sie zu Sicherheit, und klicken Sie auf Vault.
Stellen Sie im Abschnitt "Listengeltungsbereich" sicher, dass Sie sich im Dataflow Compartment befinden.
Klicken Sie auf Vault erstellen.
Geben Sie im geöffneten Bereich Dataflow in das Feld Name ein.
Klicken Sie auf Vault erstellen.
Wenn der Vault-Status Aktiv wird, klicken Sie auf Datenfluss, um die Seite "Vault-Details" zu öffnen.
Klicken Sie im Abschnitt "Masterverschlüsselung" auf Schlüssel erstellen.
Geben Sie im Bereich "Schlüssel erstellen" Datenfluss in das Feld Name ein.
Klicken Sie auf Schlüssel erstellen.
Klicken Sie im Abschnitt "Ressourcen" auf Secrets.
Klicken Sie auf Secret erstellen.
Wählen Sie im Dialogfeld "Secret erstellen" ein Compartment in der Liste "Erstellen in Compartment" aus.
Geben Sie im Feld Name einen Namen ein, um den Secret zu identifizieren. Geben Sie dabei keine vertraulichen Informationen ein.
Geben Sie im Feld Beschreibung eine kurze Beschreibung des Secrets ein, um es leichter identifizieren zu können. Geben Sie keine geschützten Informationen ein.
Wählen Sie im Feld Verschlüsselungsschlüssel die Option Datenfluss aus.
Wählen Sie im Feld Secret-Type-Vorlage die Option Nur Text aus.
Geben Sie im Feld Secret-Inhalt ein falsches Kennwort ein.
Klicken Sie auf Secret erstellen.
Wenn der Bereich geschlossen wird, klicken Sie auf das Dataflow Secret, um die Detailseite zu öffnen und die OCID zu kopieren.

PySpark-App erstellen

Die PySpark-App erstellt eine Spark-Session, in der die Logdaten aus Object Storage gelesen, in einen Datenframe transformiert und dann in einer Tabelle in ADW gespeichert werden.

Bevor Sie die Spark-Session erstellen, müssen Sie sicherstellen, dass einige wichtige Module importiert werden, und einige Konstanten für die spätere Verwendung in der App festlegen.

Verwenden Sie die folgenden Anweisungen, um die relevanten Module zu importieren.

import os
import oci
import base64
import zipfile
from urllib.parse import urlparse

from pyspark import SparkConf
from pyspark.sql import SparkSession
from pyspark.sql.functions import regexp_extract

Dies sind die Konstanten, die Sie in der Funktion main() festlegen müssen.

Stellen Sie sicher, dass Sie eigene Werte für OBJECT_STORAGE_NAMESPACE und PASSWORD_SECRET_OCID eingeben.

OBJECT_STORAGE_NAMESPACE = "YOUR-OBJECT-STORAGE-NAMESPACE"
INPUT_PATH = "oci://data@{}/sample_logs.log".format(OBJECT_STORAGE_NAMESPACE)
DATABASE_NAME = "logs"
PASSWORD_SECRET_OCID = "ocid1.vaultsecret..... "
WALLET_PATH = "oci://Wallet@{}/wallet_{}.zip".format(OBJECT_STORAGE_NAMESPACE,DATABASE_NAME)
TNS_NAME = "{}_high".format(DATABASE_NAME)
USER="ADMIN"
TARGET_DATABASE_TABLE="processed_logs"

Richten Sie die Spark-Session ein, und laden Sie die Daten aus Object Storage. Die Daten haben die Form einer Flat Text-Datei, die Sie in einen Spark-Datenframe laden.

spark_session = SparkSession.builder.appName("Dataflow").getOrCreate()
input_df = spark_session.read.text(INPUT_PATH)
input_df.show(5, truncate=False) # Some output for the Data Flow log file

Der Datenrahmen sollte dem folgenden Beispiel ähneln:

+----------------------------------------------------------------------------------+
|value                                                                             |
+----------------------------------------------------------------------------------+
|10.0.0.1 - user1 [10/Mar/2021:13:55:36 -0700] "GET /index.html HTTP/1.0" 200 2326 |
|10.0.0.2 - user2 [10/Mar/2021:14:55:36 -0700] "GET /file1.html HTTP/1.0" 200 9889 |
|10.0.0.3 - user3 [10/Mar/2021:14:55:37 -0700] "GET /file2.html HTTP/1.0" 200 4242 |
|10.0.0.4 - user4 [10/Mar/2021:14:56:36 -0700] "GET /file3.html HTTP/1.0" 200 10267|
|10.0.0.1 - user1 [10/Mar/2021:15:05:36 -0700] "GET /file4.html HTTP/1.0" 200 15678|
+----------------------------------------------------------------------------------+

Wie Sie sehen, bestehen die Daten aus einer einzelnen Spalte namens value, die jeden Logeintrag als einzelne Zeichenfolge enthält. Bevor Sie die Daten in die Datenbank übertragen können, muss der Datenrahmen mehrere Spalten enthalten, eine für jedes Feld in der Logdatei.

Teilen Sie den Datenrahmen in Spalten auf.

Im folgenden Beispiel ist das Feld Benutzer-ID (in der Regel "-") nicht im neuen Datenrahmen enthalten.

hostname = r'(^\S+\.[\S+\.]+\S+)\s'
user = r'\s+.+\s+(.+)\s+\['
timestamp = r'\[(\d{2}/\w{3}/\d{4}:\d{2}:\d{2}:\d{2} -\d{4})]'
method_uri_protocol = r'\"(\S+)\s(\S+)\s*(\S*)\"'
status = r'\s(\d{3})\s'
content_size = r'\s(\d+)$'

logdata_df = input_df.select(
    regexp_extract('value', hostname, 1).alias('hostname'),
    regexp_extract('value', user, 1).alias('user'),
    regexp_extract('value', timestamp, 1).alias('timestamp'),
    regexp_extract('value', method_uri_protocol, 1).alias('method'),
    regexp_extract('value', method_uri_protocol, 2).alias('URI'),
    regexp_extract('value', method_uri_protocol, 3).alias('protocol'),
    regexp_extract('value', status, 1).cast('integer').alias('status'),
    regexp_extract('value', content_size, 1).cast('integer').alias('content_size'))

Hier können Sie auch ein oder mehrere Modelle für maschinelles Lernen anwenden. Beispiel: Sie können eine Workload zur Angriffserkennung ausführen, bevor Sie die Logs in der Datenbank speichern.

Rufen Sie die Zugangsdaten für Ihre Autonomous Data Warehouse-Datenbank ab.

Der Terraform-Code zu diesem Tutorial erstellt das Autonomus Data Warehouse und speichert die Wallet-Datei in Object Storage. Die PySpark-App muss das Wallet abrufen und die zugehörigen Informationen für die Verbindung mit ADW verwenden.

# Get an Object Store client
token_key = "spark.hadoop.fs.oci.client.auth.delegationTokenPath"
token_path = spark_session.sparkContext.getConf().get(token_key)
with open(token_path) as fd:
    delegation_token = fd.read()
signer = oci.auth.signers.InstancePrincipalsDelegationTokenSigner(
    delegation_token=delegation_token)
object_store_client = oci.object_storage.ObjectStorageClient(config={}, signer=signer)

# Extract the wallet file location info
split_url = urlparse(WALLET_PATH)
bucket_name, namespace = split_url.netloc.split("@")
file_name = split_url.path[1:]

# Get the wallet from Object Storage.
# The response contains the wallet and some metadata
response = object_store_client.get_object(namespace, bucket_name, file_name)

# Extract the wallet from response and store it in the Spark work-dir
wallet_path = "/opt/spark/work-dir/"
zip_file_path = os.path.join(wallet_path, "temp.zip")
with open(zip_file_path, "wb") as fd:
    for chunk in response.data.raw.stream(1024 * 1024, decode_content=False):
        fd.write(chunk)
with zipfile.ZipFile(zip_file_path, "r") as zip_ref:
    zip_ref.extractall(wallet_path)

# Extract the wallet contents and add the files to the Spark context
contents = "cwallet.sso ewallet.p12 keystore.jks ojdbc.properties sqlnet.ora tnsnames.ora truststore.jks".split()
for file in contents:
    spark.sparkContext.addFile(os.path.join(wallet_path, file))

Speichern Sie die Daten in Ihrer Autonomous Data Warehouse-Datenbank.

Das folgende Snippet zeigt, wie Sie eine Verbindung zu ADW herstellen und den Datenframe in die Zieltabelle schreiben. Wenn die Tabelle nicht vorhanden ist, wird sie erstellt. Wenn die Tabelle vorhanden ist, wird sie aufgrund der Option "overwrite" im Modusparameter gelöscht und neu erstellt.

Das Kennwort wird aus Oracle Cloud Infrastructure Vault abgerufen. Sie speichern das Kennwort in den Vault, nachdem Sie den Terraform-Code ausgeführt haben. Das Platzieren des Kennworts in Vault wird später in den Schritten nach der Ausführung von Terraform behandelt.

adw_url = "jdbc:oracle:thin:@{}?TNS_ADMIN={}".format(TNS_NAME, wallet_path)

# Retrieve the database password for user 'ADMIN' from OCI Vault
# The password is stored as base64 text, so it must be decoded
with open(token_path) as fd:
    delegation_token = fd.read()
signer = oci.auth.signers.InstancePrincipalsDelegationTokenSigner(
    delegation_token=delegation_token)
secrets_client = oci.secrets.SecretsClient(config={}, signer=signer)
response = secrets_client.get_secret_bundle(PASSWORD_SECRET_OCID)

base64_password = response.data.secret_bundle_content.content
base64_secret_bytes = base64_password.encode("ascii")
base64_message_bytes = base64.b64decode(base64_secret_bytes)
password = base64_message_bytes.decode("ascii")

# Set up some properties for connecting to the database
properties = {
    "driver": "oracle.jdbc.driver.OracleDriver",
    "oracle.net.tns_admin": TNS_NAME,
    "password": password,
    "user": USER,
}

# Write the dataframe to the database
adw_url = "jdbc:oracle:thin:@{}?TNS_ADMIN={}".format(TNS_NAME, wallet_path)
logdata_df.write.jdbc(url=adw_url, table=TARGET_DATABASE_TABLE, 
    mode="Overwrite", properties=properties)

Speichern Sie die App PySpark mit dem Namen dataflow-app.py.

Terraform-Code herunterladen und anwenden

Der Terraform-Code ist im Oracle-Repository quickstart auf GitHub verfügbar. Der Code stellt die Komponenten bereit, die im Architekturdiagramm dargestellt werden.

So laden Sie den Code herunter und wenden ihn an:

Wechseln Sie in ein Verzeichnis, und klonen Sie das Repository.

git clone https://github.com/oracle-quickstart/oci-arch-dataflow-store-analyze-data
Kopieren Sie die Abhängigkeitsdatei archive.zip in das Verzeichnis oci-arch-dataflow-store-analyze-data.

Hinweis: Wenn Sie nicht über die Datei archive.zip verfügen, finden Sie weitere Informationen im Abschnitt Voraussetzungen.
Wechseln Sie in das Verzeichnis oci-arch-dataflow-store-analyze-data.

cd oci-arch-dataflow-store-analyze-data
Suchen Sie die PySpark-Anwendungsdatei dataflow-app.py, bei der es sich um eine Stub-Datei handelt, und ersetzen Sie sie durch die von Ihnen erstellte Datei.
Öffnen Sie die Datei terraform.tfvars in einem Texteditor.
Aktualisieren Sie den Wert für object_storage_namespace in terraform.tfvars. Verwenden Sie den zuvor aufgezeichneten Wert.
Ändern Sie entweder env-vars.bat oder env-vars.sh, je nachdem, welches Betriebssystem Sie verwenden. Diese Skripte werden zum Festlegen von Umgebungsvariablen verwendet, die Terraform verwendet.

Unter Windows sollte die Datei env-vars.bat dem folgenden Beispiel ähneln. Stellen Sie sicher, dass Sie die Werte für Ihren eigenen Mandanten einfügen.
```
@echo off
set TF_VAR_tenancy_ocid=ocid1.tenancy.oc1..
set TF_VAR_user_ocid=ocid1.user.oc1..
set TF_VAR_compartment_ocid=ocid1.compartment.oc1..
set TF_VAR_private_key_path=%HOMEPATH%\.ssh\oci_api_key.pem
set TF_VAR_fingerprint=2a:b4:ef:9c:f1...
set TF_VAR_region=ca-toronto-1
```
Unter Linux und Mac sollte die Datei env-vars.sh dem folgenden Beispiel ähneln. Stellen Sie sicher, dass Sie die Werte für Ihren eigenen Mandanten einfügen.
```
export TF_VAR_tenancy_ocid=ocid1.tenancy.oc1..
export TF_VAR_user_ocid=ocid1.user.oc1..
export TF_VAR_compartment_ocid=ocid1.compartment.oc1..
export TF_VAR_private_key_path=~/.ssh/oci_api_key.pem
export TF_VAR_fingerprint=2a:b4:ef:9c:f1...
export TF_VAR_region=ca-toronto-1
```
Nachdem Sie die Dateien mit Ihren eigenen Mandanten- und Benutzerinformationen aktualisiert haben, stellen Sie sicher, dass die Umgebungsvariablen festgelegt sind.

Führen Sie unter Windows den folgenden Befehl aus:
```
env-vars.bat
```
Führen Sie auf Linux oder Mac den folgenden Befehl aus:
```
source env-vars.sh
```
Führen Sie in einem Terminal den Befehl init aus.

terraform init
Stellen Sie die Ressourcen für Oracle Infrastructure Cloud bereit.

terraform apply

Wenn der Vorgang abgeschlossen ist, zeigt die Terraform-App das ADMIN-Kennwort für die erstellte Datenbank an.
Kopieren Sie das Kennwort, das in der Terraform-App angezeigt wird.
Prüfen Sie, ob die Ressourcen bereitgestellt wurden.
1. Gehen Sie zur OCI-Konsole, und öffnen Sie das Navigationsmenü.
2. Scrollen Sie nach unten zum Abschnitt Governance und Administration, blenden Sie Governance ein, und klicken Sie auf Mandanten-Explorer.
3. Wählen Sie das zuvor erstellte Dataflow-Compartment aus.
Nach einigen Sekunden werden die Ressourcen in einer Tabelle angezeigt, die Sie filtern und sortieren können.

ADMIN-Kennwort im Vault aktualisieren

Zuvor haben Sie OCI Vault ein falsches Kennwort hinzugefügt, um die OCID zur Verwendung in der PySpark-App abzurufen, die in Data Flow ausgeführt wird. Jetzt müssen Sie dieses Kennwort auf den tatsächlichen Wert aktualisieren. Der reale Wert wurde im Terminal angezeigt, als der Terraform-Befehl "apply" abgeschlossen wurde.

Wählen Sie im Navigationsmenü der Konsole Sicherheit aus, und klicken Sie auf Vault.
Klicken Sie auf den Namen des Vaults, den Sie zuvor erstellt haben.
Prüfen Sie auf der geöffneten Seite "Vault-Details" im Abschnitt "Ressourcen", und klicken Sie auf Secrets.
Klicken Sie auf den Namen des Secrets, das Sie zuvor erstellt haben.
Klicken Sie auf Secret-Version erstellen.
Stellen Sie sicher, dass die Secret-Type-Vorlage auf Nur Text gesetzt ist, und fügen Sie das ADMIN-Kennwort der Datenbank in das Feld Secret-Inhalt ein.
Klicken Sie auf Secret-Version erstellen.

Data Flow-Anwendung ausführen

Jetzt ist es an der Zeit, die PySpark-App auszuführen.

Wählen Sie im Navigationsmenü der Konsole Data Flow aus, und klicken Sie auf Anwendungen.
Klicken Sie auf On-Premise-Logs analysieren, um die Seite "Anwendungsdetails" zu öffnen.
Klicken Sie auf Ausführen, um den Bereich "Python-Anwendung ausführen" zu öffnen.
Klicken Sie auf Ausführen.

Die Seite "Datenflussausführungen" wird geöffnet, auf der Sie den Fortschritt der Ausführung überwachen können. Es dauert ein paar Minuten, die Ressourcen zuzuweisen und alles hochzufahren. Wenn die Ausführung abgeschlossen ist, klicken Sie auf den Namen der Ausführung, um die Seite "Ausführungsdetails" zu öffnen.

Auf der Seite "Ausführungsdetails" können Sie die erstellten Logs herunterladen und prüfen. Wenn die Ausführung aus irgendeinem Grund nicht erfolgreich war, können Sie die Logs prüfen, um die Quelle des Problems zu ermitteln.

Danksagungen

Autor - Jeff Schering (User Assistance Developer)
Beitragende - Prashant Jha (Director Product Management, OCI Big Data Development)

Weitere Informationen

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.

Weitere Lernressourcen

Produktdokumentation finden Sie im Oracle Help Center.

Titel und Copyright-Informationen

Store and analyze your on-premises logs in Oracle Cloud Infrastructure

F52103-01

January 2022