DataStream APIs verwenden

Bei Unternehmen mit vielen isolierten Datenquellen kann der Zugriff auf Unternehmensdaten unternehmensweit schwierig sein, vor allem in Echtzeit. Auf diese Weise wird der Zugriff auf die Daten nur begrenzt und langsam fortgesetzt.

Mit Datastream können Sie Daten nahezu in Echtzeit ändern, um Daten aus verschiedenen lokalen und cloudbasierten Datenquellen zu ändern und so Zugriff auf Unternehmensdaten zu erhalten. Datastream bietet eine einfache Einrichtung und eine einheitliche Verbrauchs-API, durch die der Zugriff auf die aktuellen Unternehmensdaten in der gesamten Organisation demokratisiert wird. Dadurch sind integrierte Szenarien nahezu in Echtzeit möglich.

Ein Beispiel hierfür ist das Übertragen von Daten aus einer Quelldatenbank in einen cloudbasierten Speicherdienst oder eine Nachrichtenwarteschlange und die Umwandlung dieser Daten in ein Formular, das für andere Anwendungen und Dienste lesbar ist, die mit diesem Speicherdienst oder dieser Nachrichtenwarteschlange kommunizieren.

In dieser Anleitung erfahren Sie, wie Sie mit Datastream Schemas, Tabellen und Daten aus einer Oracle-Quelldatenbank in einen Ordner in einem Cloud Storage-Bucket übertragen. Cloud Storage ist ein Webdienst zum Speichern und Abrufen von Daten in Google Cloud. Der Dienst kombiniert die Leistung und Skalierbarkeit der Google Cloud mit erweiterten Sicherheits- und Freigabefunktionen.

Bei der Übertragung dieser Informationen in einen Ordner im Cloud Storage-Ziel-Bucket übersetzt Datastream diese Informationen in Avro. Avro wird durch ein Schema definiert, das in JavaScript Object Notation (JSON) geschrieben ist. Durch diese Übersetzung können Sie auf einheitliche Weise Daten aus verschiedenen Datenquellen lesen.

Ziele

In dieser Anleitung erfahren Sie mehr über die folgenden Themen:

  • Umgebungsvariablen festlegen Sie verwenden diese Variablen, wenn Sie Anfragen an Datastream senden, um sowohl Verbindungsprofile als auch einen Stream zu erstellen und zu verwalten.
  • Verbindungsprofile für eine Quelldatenbank und einen Ziel-Bucket in Cloud Storage erstellen und verwalten Mit diesen Verbindungsprofilen erstellen Sie Einträge mit Informationen zur Quelldatenbank und zum Cloud Storage-Ziel-Bucket. Der Stream in Datastream verwendet die Informationen in den Verbindungsprofilen, um Daten aus der Quelldatenbank in einen Ordner im Ziel-Bucket zu übertragen.
  • Erstelle und verwalte einen Stream. Datastream verwendet diesen Stream, um Daten, Schemas und Tabellen aus der Quelldatenbank in einen Ordner im Ziel-Bucket zu übertragen.
  • Prüfen Sie, ob Datastream die Daten und Tabellen, die mit einem Schema der Oracle-Quelldatenbank verknüpft sind, in einen Ordner im Ziel-Bucket überträgt und diese Daten in das Avro-Dateiformat übersetzt.
  • Bereinigen Sie die Ressourcen, die Sie in Datastream erstellt haben, damit diese keine kostenpflichtigen Kontingente verbrauchen.

Kosten

In dieser Anleitung werden kostenpflichtige Komponenten von Google Cloud verwendet, darunter Cloud Storage.

Sie können mithilfe des Preisrechners die Kosten für Ihre voraussichtliche Nutzung kalkulieren. Neuen Google Cloud-Nutzern steht möglicherweise eine kostenlose Testversion zur Verfügung.

Hinweis

  1. Melden Sie sich bei Ihrem Google Cloud-Konto an. Wenn Sie mit Google Cloud noch nicht vertraut sind, erstellen Sie ein Konto, um die Leistungsfähigkeit unserer Produkte in der Praxis sehen und bewerten zu können. Neukunden erhalten außerdem ein Guthaben von 300 $, um Arbeitslasten auszuführen, zu testen und bereitzustellen.
  2. Wählen Sie in der Google Cloud Console auf der Seite der Projektauswahl ein Google Cloud-Projekt aus oder erstellen Sie eines.

    Zur Projektauswahl

  3. Die Abrechnung für das Cloud-Projekt muss aktiviert sein. So prüfen Sie, ob die Abrechnung für Ihr Projekt aktiviert ist.

  4. Wählen Sie in der Google Cloud Console auf der Seite der Projektauswahl ein Google Cloud-Projekt aus oder erstellen Sie eines.

    Zur Projektauswahl

  5. Die Abrechnung für das Cloud-Projekt muss aktiviert sein. So prüfen Sie, ob die Abrechnung für Ihr Projekt aktiviert ist.

  6. Aktivieren Sie die Datastream API.

    API aktivieren

  7. Vergewissern Sie sich, dass Ihrem Nutzerkonto die Rolle "Datenstream-Administrator" zugewiesen ist.

    Zur IAM-Seite

  8. Sorgen Sie dafür, dass Sie eine Quelldatenbank haben, auf die Datastream zugreifen kann. In dieser Anleitung wird eine Oracle-Datenbank als Quelle verwendet.
  9. Konfigurieren Sie Ihre Quelldatenbank so, dass eingehende Verbindungen von öffentlichen IP-Adressen des Datenstroms zugelassen werden. Unter IP-Zulassungslisten und Regionen finden Sie Informationen zum Zugriff auf die Standorte aller Datastream-Regionen und die zugehörigen öffentlichen IP-Adressen.
  10. Konfigurieren Sie einen Cloud Storage-Ziel-Bucket, auf den Datastream über die IP-Zulassungsliste, den Weiterleitungs-SSH-Tunnel oder VPC-Peering zugreifen kannMethode der Netzwerkverbindung auf Ihrem Mobilgerät.
  11. Achten Sie darauf, dass die Quelldatenbank Daten, Tabellen und Schemas enthält, die von Datastream in einen Ordner im Cloud Storage-Ziel-Bucket übertragen werden können.
  12. Laden Sie Cloud Shell herunter und installieren Sie es. Mit dieser Clientanwendung können Sie über die Befehlszeile auf Ihre Cloudressourcen einschließlich Datastream zugreifen.
  13. Installieren und konfigurieren Sie das Dienstprogramm jq. Dieses Dienstprogramm ist ein einfacher und flexibler JSON-Befehlszeilenprozessor. Mit diesem Prozessor werden komplexe cURL-Befehle in leicht lesbarem Text dargestellt.

Umgebungsvariablen festlegen

Bei diesem Verfahren legen Sie die folgenden Variablen fest:

  • $PROJECT: Diese Variable ist mit Ihrem Google Cloud-Projekt verknüpft. Alle Google Cloud-Ressourcen, die Sie zuweisen und nutzen, müssen zu einem Projekt gehören.
  • $TOKEN: Diese Variable ist mit einem Zugriffstoken verknüpft. Das Zugriffstoken stellt eine Sitzung bereit, die Cloud Shell verwendet, um Aufgaben in Datastream über REST APIs auszuführen.
  1. Starten Sie die Cloud Shell-Anwendung.

  2. Nachdem Sie sich mit Ihrem Google-Konto bei Ihrer Anwendung authentifiziert haben, geben Sie gcloud auth login ein.

  3. Geben Sie bei der Eingabeaufforderung Do you want to continue (Y/n)? Y ein.

  4. Öffnen Sie einen Webbrowser und kopieren Sie die URL in den Browser.

  5. Authentifizieren Sie sich mit Ihrem Google-Konto beim Google Cloud SDK. Auf der Seite Anmelden wird ein Code angezeigt. Dieser Code ist Ihr Zugriffstoken.

  6. Kopieren Sie das Zugriffstoken, fügen Sie es im Parameter Enter verification code: Ihrer Cloud Shell-Anwendung ein und drücken Sie Enter.

  7. Geben Sie bei Aufforderung PROJECT="[YOUR_PROJECT_NAME]" ein, um die Umgebungsvariable $PROJECT auf Ihr Google Cloud-Projekt festzulegen.

  8. Geben Sie an der Eingabeaufforderung gcloud config set project [YOUR_PROJECT_NAME] ein, um das Projekt festzulegen, das Sie an Ihrem Google Cloud-Projekt bearbeiten möchten.

    Die Eingabeaufforderung wird aktualisiert, sodass sie dem aktuell aktiven Projekt entspricht und folgendes Format berücksichtigt: [USERNAME]@cloudshell:~ ([YOUR_PROJECT_NAME])$

  9. Geben Sie an der Eingabeaufforderung TOKEN=$(gcloud auth print-access-token) ein, um das Zugriffstoken abzurufen und es als Variable zu speichern.

  10. Geben Sie an der Eingabeaufforderung die folgenden Befehle ein, damit die Variablen $PROJECT und $TOKEN richtig festgelegt sind:

    • echo $PROJECT
    • echo $TOKEN

Nachdem Sie die Variablen eingerichtet haben, können Sie Anfragen an Datastream senden, um sowohl Verbindungsprofile als auch einen Stream zu erstellen und zu verwalten.

Verbindungsprofile erstellen und verwalten

In diesem Abschnitt erstellen und verwalten Sie Verbindungsprofile für eine Oracle-Quelldatenbank und einen Ziel-Bucket in Cloud Storage.

Beim Erstellen dieser Verbindungsprofile erstellen Sie Einträge mit Informationen zur Quelldatenbank und zum Cloud Storage-Ziel-Bucket. Datastream verwendet die Informationen in den Verbindungsprofilen, um Daten aus der Quelldatenbank in einen Ordner im Ziel-Bucket zu übertragen.

Das Erstellen und Verwalten von Verbindungsprofilen umfasst Folgendes:

  • Verbindungsprofile für eine Oracle-Quelldatenbank und einen Ziel-Bucket in Cloud Storage erstellen
  • Informationen zu einem Verbindungsprofil abrufen
  • Verbindungsprofil ändern
  • API-Aufruf für das Oracle-Quellverbindungsprofil ausführen Mit diesem Aufruf können Sie die Datenbank überprüfen, um die mit ihr verknüpften Objekte zu sehen. Diese Objekte enthalten die Schemas und Tabellen, die die Daten der Datenbank enthalten. Wenn Sie einen Stream mit Datastream konfigurieren, möchten Sie möglicherweise nicht alle Objekte, sondern nur einen Teil der Objekte (z. B. nur bestimmte Tabellen und Schemas der Datenbank) aus der Datenbank abrufen. Mit der Discover API können Sie die Teilmenge der Datenbankobjekte suchen, die Sie abrufen möchten, oder sie entdecken.

Verbindungsprofile erstellen

In diesem Verfahren erstellen Sie zwei Verbindungsprofile: eines für eine Oracle-Quelldatenbank und ein weiteres für einen Ziel-Bucket in Cloud Storage.

  1. Verbindungsprofil zu einer Oracle-Quelldatenbank erstellen Geben Sie an der Eingabeaufforderung den folgenden Befehl ein:

    ORACLE="{\"displayName\":\"[DISPLAY_NAME]\",\"oracle_profile\":{\"hostname\":\"[HOSTNAME],\"username\":\"[USERNAME]\",\"password\":\"[PASSWORD]\",\"database_service\":\"[DATABASE_SERVICE]\",\"port\":[PORT_NUMBER]},\"no_connectivity\":{}}"
    

    In der folgenden Tabelle finden Sie Informationen zu den Parameterwerten für die Oracle-Quelldatenbank:

    ParameterwertErsetzen durch
    [DISPLAY_NAME]Der Anzeigename des Verbindungsprofils für die Quelldatenbank.
    [HOSTNAME]Der Hostname des Quelldatenbankservers.
    [USERNAME]Der Nutzername des Kontos für die Quelldatenbank (z. B. ROOT).
    [PASSWORD]Das Passwort des Kontos für die Quelldatenbank.
    [DATABASE_SERVICE]Der Dienst, der die Quelldatenbank schützt und überwacht. Bei Oracle-Datenbanken ist der Datenbankdienst normalerweise ORCL.
    [PORT_NUMBER]Die für die Quelldatenbank reservierte Portnummer. Bei einer Oracle-Datenbank ist die Portnummer normalerweise 1521.
  2. Geben Sie bei der Eingabeaufforderung den Befehl echo $ORACLE | jq ein, um das von Ihnen erstellte Quellverbindungsprofil in leicht lesbarer Textform aufzurufen.

    {
      "displayName": "[DISPLAY_NAME]",
      "oracle_profile": {
        "hostname": "[HOSTNAME]",
        "username": "[USERNAME]",
        "password": "[PASSWORD]",
        "database_service": "[DATABASE_SERVICE]",
        "port": [PORT_NUMBER]
       },
      "no_connectivity": {}
    }
    
  3. Senden Sie das Oracle-Verbindungsprofil, damit es erstellt werden kann. Geben Sie an der Eingabeaufforderung den folgenden Befehl ein:

    curl -X POST -d $ORACLE -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" https://datastream.googleapis.com/[DATASTREAM_API_VERSION]/[PROJECT_PATH]/connectionProfiles?connection_profile_id=[SOURCE_CONNECTION_PROFILE_ID]
    

    In der folgenden Tabelle finden Sie Informationen zu den Parameterwerten für diesen Befehl:

    ParameterwertErsetzen durch
    [DATASTREAM_API_VERSION]Die aktuelle Version der Datastream API (z. B. v1alpha1).
    [PROJECT_PATH]Der vollständige Pfad Ihres Google Cloud-Projekts (z. B. projects/$PROJECT/locations/[YOUR_PROJECT_LOCATION]))
    [SOURCE_CONNECTION_PROFILE_ID]Die eindeutige ID, die für dieses Verbindungsprofil reserviert ist, z. B. cp-1.
  4. Prüfen Sie, ob die folgenden Codezeilen angezeigt werden:

    {
      "name": "[PROJECT_PATH]/operations/operation-[SOURCE_CONNECTION_PROFILE_OPERATION_ID]",
      "metadata": {
        "@type": "type.googleapis.com/google.cloud.datastream.[DATASTREAM_API_VERSION].OperationMetadata",
        "createTime": "[DATE_AND_TIME_STAMP]",
        "target": "datastream.googleapis.com/[DATASREAM_VERSION]/[PROJECT_PATH]/connectionProfiles/[SOURCE_CONNECTION_PROFILE_ID]",
        "verb": "create",
        "requestedCancellation": false,
        "apiVersion": "[DATASTREAM_API_VERSION]"
      },
      "done": false
    }
    
  5. Erstellen Sie ein Verbindungsprofil zu einem Ziel-Bucket in Cloud Storage. Geben Sie an der Eingabeaufforderung den folgenden Befehl ein:

    GOOGLECLOUDSTORAGE="{\"displayName\":\"[DISPLAY_NAME]\",\"gcs_profile\":{\"bucket_name\":\"[BUCKET_NAME]\",\"root_path\":\"/[FOLDER_PATH]\"},\"no_connectivity\":{}}"
    

    In der folgenden Tabelle finden Sie Informationen zu den Parameterwerten für den Ziel-Bucket:

    ParameterwertErsetzen durch
    [DISPLAY_NAME]Der Anzeigename des Verbindungsprofils für den Ziel-Bucket.
    [BUCKET_NAME]Der Name des Ziel-Buckets.
    [FOLDER_PATH]Der Ordner im Ziel-Bucket, in den Datastream Daten aus der Quelldatenbank übertragen soll (z. B. /root/path).
  6. Geben Sie an der Eingabeaufforderung den Befehl echo $GOOGLECLOUDSTORAGE | jq ein, um das von Ihnen erstellte Zielverbindungsprofil in leicht lesbarer Textform zu sehen.

    {
      "displayName": "[DISPLAY_NAME]",
      "gcs_profile": {
        "bucket_name": "[BUCKET_NAME]",
        "root_path": "/[FOLDER_PATH]"
      },
      "no_connectivity": {}
    }
    
  7. Senden Sie das Cloud Storage-Verbindungsprofil, damit es erstellt werden kann. Geben Sie an der Eingabeaufforderung den folgenden Befehl ein:

    curl -X POST -d $GOOGLECLOUDSTORAGE -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" https://datastream.googleapis.com/[DATASTREAM_API_VERSION]/[PROJECT_PATH]/connectionProfiles?connection_profile_id=[DESTINATION_CONNECTION_PROFILE_ID]
    
  8. Prüfen Sie, ob die folgenden Codezeilen angezeigt werden:

    {
      "name": "[PROJECT_PATH]/operations/operation-[DESTINATION_CONNECTION_PROFILE_OPERATION_ID]",
      "metadata": {
        "@type": "@type": "type.googleapis.com/google.cloud.datastream.[DATASTREAM_API_VERSION].OperationMetadata",
        "createTime": "[DATE_AND_TIME_STAMP]",
        "target": "datastream.googleapis.com/[DATASREAM_VERSION]/[PROJECT_PATH]/connectionProfiles/[DESTINATION_CONNECTION_PROFILE_ID]",
        "verb": "create",
        "requestedCancellation": false,
        "apiVersion": "[DATASTREAM_API_VERSION]"
      },
      "done": false
    }
    
  9. Prüfen Sie, ob beide Verbindungsprofile erstellt wurden. Geben Sie an der Eingabeaufforderung den folgenden Befehl ein:

    curl -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" https://datastream.googleapis.com/[DATASTREAM_API_VERSION]/[PROJECT_PATH]/connectionProfiles
    
  10. Achten Sie darauf, dass Sie zwei zurückgegebene Ergebnisse für das Quell- und Zielverbindungsprofil erhalten.

    {
      "connectionProfiles": [
        {
          "name": "[PROJECT_PATH]/connectionProfiles/[DESTINATION_CONNECTION_PROFILE_ID]",
          "createTime": "[DATE_AND_TIME_STAMP]",
          "updateTime": "[DATE_AND_TIME_STAMP]",
          "displayName": "[DISPLAY_NAME]",
          "gcsProfile": {
            "bucketName": "[BUCKET_NAME]",
            "rootPath": "[FOLDER_PATH]"
          },
          "noConnectivity": {}
        },
       {
        "name": "[PROJECT_PATH]/connectionProfiles/[SOURCE_CONNECTION_PROFILE_ID]",
        "createTime": "[DATE_AND_TIME_STAMP]",
        "updateTime": "[DATE_AND_TIME_STAMP]",
        "displayName": "[DISPLAY_NAME]",
        "oracleProfile": {
          "hostname": "[HOSTNAME]",
          "port": [PORT_NUMBER],
          "username": "[USERNAME]",
          "databaseService": "[DATABASE_SERVICE]"
        },
        "noConnectivity": {}
        }
      ]
    }
    

Verbindungsprofile verwalten

In diesem Verfahren verwalten Sie die Verbindungsprofile, die Sie für eine Oracle-Quelldatenbank und einen Ziel-Bucket in Cloud Storage erstellt haben. Dazu zählen:

  • Informationen zum Cloud Storage-Zielprofil abrufen
  • Dieses Verbindungsprofil wird geändert. Für diese Anleitung ändern Sie den Ordner des Cloud Storage-Ziel-Buckets in /root/tutorial. Datastream überträgt Daten aus der Quelldatenbank in diesen Ordner.
  • Discover-API-Aufruf für das Oracle-Quellverbindungsprofil ausführen
  1. Informationen zum Cloud Storage-Zielprofil für das Ziel abrufen Geben Sie an der Eingabeaufforderung den folgenden Befehl ein:

    curl -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" https://datastream.googleapis.com/[DATASTREAM_API_VERSION]/[PROJECT_PATH]/connectionProfiles/[DESTINATION_CONNECTION_PROFILE_ID]
    
  2. Sehen Sie nach, ob Informationen zu diesem Verbindungsprofil angezeigt werden.

    {
      "name": "[PROJECT_PATH]/connectionProfiles/[DESTINATION_CONNECTION_PROFILE_ID]",
      "createTime": "[DATE_AND_TIME_STAMP]",
      "updateTime": "[DATE_AND_TIME_STAMP]",
      "displayName": "[DISPLAY_NAME]",
      "gcsProfile": {
        "bucketName": "[BUCKET_NAME]",
        "rootPath": "[FOLDER_PATH]"
      },
      "noConnectivity": {}
    }
    
  3. Ändern Sie dieses Verbindungsprofil. Legen Sie dazu eine UPDATE-Variable fest. Sie enthält die Werte des Verbindungsprofils, das Sie ändern möchten. Für diese Anleitung ändern Sie den Ordner des Ziel-Buckets in /root/tutorial.

    Um die Variable festzulegen, geben Sie an der Eingabeaufforderung den folgenden Befehl ein:

    UPDATE="{\"gcsProfile\":{\"rootPath\":\"/root/tutorial\"}}"
  4. Geben Sie an der Eingabeaufforderung den folgenden Befehl ein:

    curl -X PATCH -d $UPDATE -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" https://datastream.googleapis.com/[DATASTREAM_API_VERSION]/[PROJECT_PATH]/connectionProfiles/[DESTINATION_CONNECTION_PROFILE_ID]?update_mask=gcsProfile.rootPath
    
  5. Prüfen Sie, ob die folgenden Codezeilen angezeigt werden:

    {
      "name": "[PROJECT_PATH]/operations/operation-[DESTINATION_CONNECTION_PROFILE_OPERATION_ID]",
      "metadata": {
        "@type": "type.googleapis.com/google.cloud.datastream.[DATASTREAM_API_VERSION].OperationMetadata",
        "createTime": "[DATE_AND_TIME_STAMP]",
        "target": "[PROJECT_PATH]/connectionProfiles/[DESTINATION_CONNECTION_PROFILE_ID]",
        "verb": "update",
        "requestedCancellation": false,
        "apiVersion": "[DATASTREAM_API_VERSION]"
      },
      "done": false
    }
    
  6. Prüfen Sie, ob das Verbindungsprofil geändert wurde. Geben Sie an der Eingabeaufforderung den folgenden Befehl ein:

    curl -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" https://datastream.googleapis.com/[DATASTREAM_API_VERSION]/[PROJECT_PATH]/connectionProfiles/[DESTINATION_CONNECTION_PROFILE_ID]
    
  7. Prüfen Sie, ob der Ordner des Ziel-Buckets des Cloud Storage-Verbindungsprofils jetzt /root/tutorial ist.

    {
      "name": "[PROJECT_PATH]/connectionProfiles/[DESTINATION_CONNECTION_PROFILE_ID]",
      "createTime": "[DATE_AND_TIME_STAMP]",
      "updateTime": "[DATE_AND_TIME_STAMP]",
      "displayName": "[DISPLAY_NAME]",
      "gcsProfile": {
        "bucketName": "[BUCKET_NAME]",
        "rootPath": "/root/tutorial"
      },
      "noConnectivity": {}
    }
    
  8. Mit der Datastream Discover API können Sie die Schemas und Tabellen der Oracle-Quelldatenbank ermitteln. Datastream bietet über das Quellverbindungsprofil Zugriff auf diese Datenbank.

    1. Schemas der Oracle-Datenbank entdecken Geben Sie an der Eingabeaufforderung den folgenden Befehl ein:

      curl -X POST -d "{"connection_profile_name":"projects/[YOUR_PROJECT_NUMBER]/locations/[YOUR_PROJECT_LOCATION]/connectionProfiles/[SOURCE_CONNECTION_PROFILE_ID]"}" -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" https://datastream.googleapis.com/[DATASTREAM_API_VERSION]/[PROJECT_PATH]/connectionProfiles:discover
        

    2. Prüfen, ob Datastream alle Schemas Ihrer Datenbank abruft

    3. Tabellen eines Schemas in Ihrer Datenbank abrufen In dieser Anleitung rufen Sie mit der Discover API die Tabellen des Schemas ROOT ab. Sie können jedoch die Tabellen der einzelnen Schemas in Ihrer Datenbank ermitteln.

      Geben Sie an der Eingabeaufforderung den folgenden Befehl ein:

      curl -X POST -d "{\"connection_profile_name\":\"projects/[YOUR_PROJECT_NUMBER]/locations/[YOUR_PROJECT_LOCATION]/connectionProfiles/[SOURCE_CONNECTION_PROFILE_ID]\", \"oracle_rdbms\":{\"oracleSchemas\":[{\"schemaName\":\"ROOT\"}]}}" -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" https://datastream.googleapis.com/[DATASTREAM_API_VERSION]/[PROJECT_PATH]/connectionProfiles:discover
      
    4. Prüfen Sie, ob Datastream alle Tabellen des von Ihnen angegebenen Schemas abruft. In dieser Anleitung wird das Schema ROOT verwendet.

Nachdem Sie Verbindungsprofile für eine Oracle-Quelldatenbank und einen Ziel-Bucket in Cloud Storage erstellt und verwaltet haben, können Sie einen Stream in Datastream erstellen und verwalten.

Stream erstellen und verwalten

In diesem Abschnitt erstellen und verwalten Sie einen Stream. Datastream verwendet diesen Stream, um Daten, Schemas und Tabellen aus der Quelldatenbank in einen Ordner im Cloud Storage-Ziel-Bucket zu übertragen.

Das Erstellen und Verwalten eines Streams umfasst:

  • Prüfen, ob der Stream erfolgreich ausgeführt wird und alle Validierungsprüfungen erfolgreich sind. Zu diesen Prüfungen gehören:
    • Ob die Quelle richtig konfiguriert ist, damit Datastream Daten von ihr streamen kann.
    • Gibt an, ob der Stream sowohl mit der Quelle als auch mit dem Ziel verbunden werden kann.
    • Die End-to-End-Konfiguration des Streams.
  • Erstellen Sie den Stream mit den folgenden Listen:
    • Eine Zulassungsliste Mit dieser Liste werden die Tabellen und Schemas in der Quelldatenbank angegeben, die Datastream in einen Ordner im Ziel-Bucket in Cloud Storage übertragen kann. In dieser Anleitung ist dies der Ordner /root/tutorial.
    • Eine Ablehnungsliste Mit dieser Liste werden die Tabellen und Schemas in der Quelldatenbank angegeben, auf die Datastream nicht in den Ordner im Cloud Storage-Ziel-Bucket übertragen kann.
  • Informationen zum Stream abrufen
  • Stream ändern
  • Starten des Streams, damit Datastream Daten, Schemas und Tabellen aus der Quelldatenbank in einen Ordner im Cloud Storage-Ziel-Bucket übertragen kann.
  • Abrufen der Fehler mit dem Stream mithilfe der Fetch Errors API
  • Der Stream wird pausiert. Wenn ein Stream pausiert ist, ruft Datastream keine neuen Daten aus der Quelldatenbank in den Ziel-Bucket ein.
  • Der pausierte Stream wird fortgesetzt, damit Datastream weiterhin Daten in den Ziel-Bucket übertragen kann.

Stream erstellen

In diesem Verfahren erstellen Sie einen Stream aus der Oracle-Quelldatenbank in einen Ordner im Cloud Storage-Ziel-Bucket. Der Stream, den du erstellst, enthält sowohl eine Zulassungsliste als auch eine Ablehnungsliste.

  1. Legen Sie eine Variable SCHEMAS fest. Mit dieser Variablen werden die Schemas definiert, die die Daten und Tabellen enthalten, die von Datastream aus der Quelldatenbank abgerufen und in den Ordner /root/tutorial des Cloud Storage-Ziel-Buckets übertragen werden sollen. Für diese Anleitung legen Sie die Variable SCHEMAS, die dem Schema ROOT zugeordnet werden soll, fest.

    Geben Sie an der Eingabeaufforderung den folgenden Befehl ein:

    SCHEMAS="{\"oracleSchemas\":[{\"schemaName\":\"ROOT\"}]}"
    
  2. Geben Sie an der Eingabeaufforderung den Befehl echo $SCHEMAS | jq ein, um das von Ihnen für diese Variable definierte ROOT-Schema in leicht lesbarem Text anzuzeigen.

  3. Erstelle einen Stream. Geben Sie an der Eingabeaufforderung den folgenden Befehl ein:

    STREAM="{\"display_name\":\"[DISPLAY_NAME]\",\"source_config\":{\"source_connection_profile_name\":\"[PROJECT_PATH]/connectionProfiles/[SOURCE_CONNECTION_PROFILE_ID]",\"oracle_source_config\":{\"allowlist\":$SCHEMAS,\"rejectlist\":{}}},\"destination_config\":{\"destination_connection_profile_name\":\"[PROJECT_PATH]/connectionProfiles/[DESTINATION_CONNECTION_PROFILE_ID]\",\"gcs_destination_config\":{\"file_rotation_mb\":5,\"file_rotation_interval\":{\"seconds\":15},\"avro_file_format\":{}},\"backfill_all\":{}}"
    
  4. Geben Sie bei Aufforderung den Befehl echo $STREAM | jq ein, um den von Ihnen erstellten Stream in leicht lesbarer Textform zu sehen.

    {
      "display_name": "[DISPLAY_NAME]",
      "source_config": {
        "source_connection_profile_name": "[PROJECT_PATH]/connectionProfiles/[SOURCE_CONNECTION_PROFILE_ID]",
        "oracle_source_config": {
          "allowlist": {
            "oracleSchemas": [
              {
                "schemaName": "ROOT"
              }
            ]
          },
          "rejectlist": {}
        }
      },
      "destination_config": {
        "destination_connection_profile_name": "[PROJECT_PATH]/connectionProfiles/[DESTINATION_CONNECTION_PROFILE_ID]",
        "gcs_destination_config": {
          "file_rotation_mb": 5,
          "file_rotation_interval": {
            "seconds": 15
          },
          "avro_file_format": {}
        }
      },
      "backfill_all": {}
    }
    

    In dieser Tabelle werden die folgenden Parameter des Streams erläutert:

    ParameterBeschreibung
    allowlistDie Schemas, die Tabellen und Daten enthalten und von der Quelldatenbank in einen Ordner des Cloud Storage-Ziel-Buckets übertragen werden. Für diese Anleitung werden alle Tabellen und Daten aus dem Schema ROOT (und nur aus diesem Schema) in den Ordner /root/tutorial des Ziel-Buckets übertragen.
    rejectlistAlle Schemas, die Tabellen und Daten enthalten und nicht in einen Ordner des Cloud Storage-Ziel-Buckets übertragen werden. In dieser Anleitung weist der Wert {} darauf hin, dass die Übertragung von Tabellen und Daten aus der Quelldatenbank in den Ziel-Bucket verhindert wird.
    file_rotation_mbDie Größe (in Megabyte) von Dateien mit Daten, die aus der Quelldatenbank in einen Ordner im Cloud Storage-Ziel-Bucket übertragen werden. Wenn Sie aus dieser Anleitung Daten aus der Quelldatenbank abrufen, werden sie in Dateien mit 5 MB geschrieben. Falls Daten diese Größe überschreiten, werden die Daten in mehrere Dateien mit je 5 MB aufgeteilt.
    file_rotation_intervalDie Anzahl von Sekunden, die verstreichen, bevor Datastream eine vorhandene Datei in einem Ordner des Cloud Storage-Ziel-Buckets schließt und eine weitere Datei mit Daten enthält, die aus der Quelldatenbank übertragen werden. In dieser Anleitung ist das Intervall für die Dateirotation auf 15 Sekunden eingestellt.
    avro_file_format

    Das Format der Dateien, die Datastream von der Quelldatenbank in einen Ordner des Cloud Storage-Ziel-Buckets überträgt. In dieser Anleitung ist das Dateiformat Avro.

    backfill_all

    Dieser Parameter ist dem bisherigen Backfill zugeordnet. Wenn Sie diesen Parameter auf ein leeres Wörterbuch ({}) setzen, erstellt Datastream einen Backfill:

    • Zusätzlich zu den laufenden Änderungen an den Daten, z. B. Verlaufsdaten, von der Quelldatenbank bis zum Ziel.
    • Schemas und Tabellen, von der Quelle bis zum Ziel.
  5. Validieren Sie den Stream, um zu gewährleisten, dass er erfolgreich ausgeführt wird und alle Validierungsprüfungen erfolgreich sind. Geben Sie an der Eingabeaufforderung den folgenden Befehl ein:

    curl -X POST -d $STREAM -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" "https://datastream.googleapis.com/[DATASTREAM_API_VERSION]/[PROJECT_PATH]/streams?stream_id=[STREAM_ID]&validate_only=true"
    
  6. Prüfen Sie, ob die Codezeile {} angezeigt wird. Das bedeutet, dass der Stream alle Überprüfungsprüfungen bestanden hat und keine Fehler mit dem Stream verknüpft sind.

  7. Reichen Sie den Stream ein, damit er erstellt werden kann. Geben Sie an der Eingabeaufforderung den folgenden Befehl ein:

    curl -X POST -d $STREAM -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" https://datastream.googleapis.com/[DATASTREAM_API_VERSION]/[PROJECT_PATH]/streams?stream_id=[STREAM_ID]
    
  8. Prüfen Sie, ob die folgenden Codezeilen angezeigt werden:

    {
      "name": "[PROJECT_PATH]/operations/operation-[STREAM_OPERATION_ID]",
      "metadata": {
        "@type": "type.googleapis.com/google.cloud.datastream.[DATASTREAM_API_VERSION].OperationMetadata",
        "createTime": "[DATE_AND_TIME_STAMP]",
        "target": "[PROJECT_PATH]/streams/[STREAM_ID]",
        "verb": "create",
        "requestedCancellation": false,
        "apiVersion": "[DATASTREAM_API_VERSION]"
      },
      "done": false
    }
    
  9. Bestätigen Sie, dass der Stream erstellt wurde. Geben Sie an der Eingabeaufforderung den folgenden Befehl ein:

    curl -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" https://datastream.googleapis.com/[DATASTREAM_API_VERSION]/[PROJECT_PATH]/streams
    
  10. Prüfen Sie, ob Sie ein zurückgegebenes Ergebnis für den von Ihnen erstellten Stream erhalten.

    {
      "streams": [
        {
          "name": "[PROJECT_PATH]/streams/[STREAM_ID]",
          "createTime": "[DATE_AND_TIME_STAMP]",
          "updateTime": "[DATE_AND_TIME_STAMP]",
          "displayName": "[DISPLAY_NAME]",
          "sourceConfig": {
            "sourceConnectionProfileName": "projects/[YOUR_PROJECT_NUMBER]/locations/[YOUR_PROJECT_LOCATION]/connectionProfiles/[SOURCE_CONNECTION_PROFILE_ID]",
            "oracleSourceConfig": {
              "allowlist": {
                "oracleSchemas": [
                  {
                    "schemaName": "ROOT"
                  }
                ]
              },
              "rejectlist": {}
            }
          },
          "destinationConfig": {
            "destinationConnectionProfileName": "projects/[YOUR_PROJECT_NUMBER]/locations/[YOUR_PROJECT_LOCATION]/connectionProfiles/[DESTINATION_CONNECTION_PROFILE_ID]",
          "gcsDestinationConfig": {
              "fileRotationMb": 5,
              "fileRotationInterval": "15s"
              "avroFileFormat": {}
            }
          },
          "state": "CREATED",
          "backfillAll": {}
        }
      ]
    }
    

Stream verwalten

Bei diesem Verfahren verwenden Sie den erstellten Stream, um Daten aus einer Oracle-Quelldatenbank in einen Ordner in einem Cloud Storage-Ziel-Bucket zu übertragen. Dazu zählen:

  • Informationen zum Stream abrufen
  • Stream ändern
  • Der Stream wird gestartet
  • Abrufen der Fehler mit dem Stream mithilfe der Fetch Errors API
  • Stream pausieren und fortsetzen
  1. Informationen zum Stream abrufen Geben Sie an der Eingabeaufforderung den folgenden Befehl ein:

    curl -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" https://datastream.googleapis.com/[DATASTREAM_API_VERSION]/[PROJECT_PATH]/streams/[STREAM_ID]
    
  2. Vergewissern Sie sich, dass Sie Informationen zu diesem Stream sehen.

    {
      "name": "[PROJECT_PATH]/streams/[STREAM_ID]",
      "createTime": "[DATE_AND_TIME_STAMP]",
      "updateTime": "[DATE_AND_TIME_STAMP]",
      "displayName": "[DISPLAY_NAME]",
      "sourceConfig": {
        "sourceConnectionProfileName": "projects/[YOUR_PROJECT_NUMBER]/locations/[YOUR_PROJECT_LOCATION]/connectionProfiles/[SOURCE_CONNECTION_PROFILE_ID]",
        "oracleSourceConfig": {
          "allowlist": {
            "oracleSchemas": [
              {
                "schemaName": "ROOT"
              }
            ]
          },
          "rejectlist": {}
         }
        },
        "destinationConfig": {
          "destinationConnectionProfileName": "projects/[YOUR_PROJECT_NUMBER]/locations/[YOUR_PROJECT_LOCATION]/connectionProfiles/[DESTINATION_CONNECTION_PROFILE_ID]",
          "gcsDestinationConfig": {
            "fileRotationMb": 5,
            "fileRotationInterval": "15s"
            "avroFileFormat": {}
          }
        },
        "state": "CREATED",
        "backfillAll": {}
      }
    
  3. Diesen Stream ändern. Legen Sie dazu eine UPDATE-Variable fest. Sie enthält die Werte des Streams, den Sie ändern möchten. Ändern Sie für diese Anleitung die Größe von Dateien in MB, die von der Quelldatenbank übertragen werden, in einen Ordner im Cloud Storage-Ziel-Bucket (von 5 auf 100 MB). Während die Daten aus der Quelldatenbank abgerufen werden, werden sie jetzt in Dateien mit 100 MB geschrieben. Falls Daten diese Größe überschreiten, werden die Daten in mehrere Dateien mit je 100 MB aufgeteilt.

    Um die Variable festzulegen, geben Sie an der Eingabeaufforderung den folgenden Befehl ein:

    UPDATE="{\"destination_config\":{\"gcs_destination_config\":{\"file_rotation_mb\":100}}}"
    
  4. Geben Sie an der Eingabeaufforderung den folgenden Befehl ein:

    curl -X PATCH -d $UPDATE -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" https://datastream.googleapis.com/[DATASTREAM_API_VERSION]/[PROJECT_PATH]/streams/[STREAM_ID]/?update_mask=destination_config.gcs_destination_config.file_rotation_mb
    
  5. Prüfen Sie, ob die folgenden Codezeilen angezeigt werden:

    {
      "name": "[PROJECT_PATH]/operations/operation-[STREAM_OPERATION_ID]",
      "metadata": {
        "@type": "type.googleapis.com/google.cloud.datastream.[DATASTREAM_API_VERSION].OperationMetadata",
        "createTime": "[DATE_AND_TIME_STAMP]",
        "target": "[PROJECT_PATH]/streams/[STREAM_ID]",
        "verb": "update",
        "requestedCancellation": false,
        "apiVersion": "[DATASTREAM_API_VERSION]"
      },
      "done": false
    }
    
  6. Prüfen Sie, ob der Stream geändert wurde. Geben Sie an der Eingabeaufforderung den folgenden Befehl ein:

    curl -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" https://datastream.googleapis.com/[DATASTREAM_API_VERSION]/[PROJECT_PATH]/streams/[STREAM_ID]
    
  7. Prüfen Sie, ob der Wert des Parameters fileRotationMb für das Cloud Storage-Verbindungsprofil jetzt 100 ist.

    {
      "name": "[PROJECT_PATH]/streams/[STREAM_ID]",
      "createTime": "[DATE_AND_TIME_STAMP]",
      "updateTime": "[DATE_AND_TIME_STAMP]",
      "displayName": "[DISPLAY_NAME]",
      "sourceConfig": {
        "sourceConnectionProfileName": "projects/[YOUR_PROJECT_NUMBER]/locations/[YOUR_PROJECT_LOCATION]/connectionProfiles/[SOURCE_CONNECTION_PROFILE_ID]",
        "oracleSourceConfig": {
          "allowlist": {
            "oracleSchemas": [
              {
                "schemaName": "ROOT"
              }
            ]
          },
          "rejectlist": {}
         }
        },
        "destinationConfig": {
          "destinationConnectionProfileName": "projects/[YOUR_PROJECT_NUMBER]/locations/[YOUR_PROJECT_LOCATION]/connectionProfiles/[DESTINATION_CONNECTION_PROFILE_ID]",
          "gcsDestinationConfig": {
            "fileRotationMb": 100,
            "fileRotationInterval": "15s"
            "avroFileFormat": {}
          }
        },
        "state": "CREATED",
        "backfillAll": {}
      }
    
  8. Starte den Stream. Anleitung:

    1. Ändern Sie die Variable UPDATE. Geben Sie an der Eingabeaufforderung den folgenden Befehl ein:

      UPDATE="{\"state\":\"RUNNING\"}"
      
    2. Geben Sie dann den folgenden Befehl ein:

      curl -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" https://datastream.googleapis.com/[DATASTREAM_API_VERSION]/[PROJECT_PATH]/streams/[STREAM_ID]?updateMask=state
      
  9. Prüfen Sie, ob die folgenden Codezeilen angezeigt werden.

    {
      "name": "[PROJECT_PATH]/operations/operation-[STREAM_OPERATION_ID]",
      "metadata": {
        "@type": "type.googleapis.com/google.cloud.datastream.[DATASTREAM_API_VERSION].OperationMetadata",
        "createTime": "[DATE_AND_TIME_STAMP]",
        "target": "[PROJECT_PATH]/streams/[STREAM_ID]",
        "verb": "start",
        "requestedCancellation": false,
        "apiVersion": "[DATASTREAM_API_VERSION]"
      },
      "done": false
    }
    
  10. Rufen Sie nach einigen Minuten Informationen zum Stream ab, um zu prüfen, ob er gestartet wurde.

    curl -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" https://datastream.googleapis.com/[DATASTREAM_API_VERSION]/[PROJECT_PATH]/streams/[STREAM_ID]
    
  11. Prüfen Sie, ob der Status des Streams von CREATED zu RUNNING geändert wurde.

    {
      "name": "[PROJECT_PATH]/streams/[STREAM_ID]",
      "createTime": "[DATE_AND_TIME_STAMP]",
      "updateTime": "[DATE_AND_TIME_STAMP]",
      "displayName": "[DISPLAY_NAME]",
      "sourceConfig": {
        "sourceConnectionProfileName": "projects/[YOUR_PROJECT_NUMBER]/locations/[YOUR_PROJECT_LOCATION]/connectionProfiles/[SOURCE_CONNECTION_PROFILE_ID]",
        "oracleSourceConfig": {
          "allowlist": {
            "oracleSchemas": [
              {
                "schemaName": "ROOT"
              }
            ]
          },
          "rejectlist": {}
        }
      },
      "destinationConfig": {
        "destinationConnectionProfileName": "projects/[YOUR_PROJECT_NUMBER]/locations/[YOUR_PROJECT_LOCATION]/connectionProfiles/[DESTINATION_CONNECTION_PROFILE_ID]",
        "gcsDestinationConfig": {
          "fileRotationMb": 100,
          "fileRotationInterval": "15s"
          "avroFileFormat": {}
        }
      },
      "state": "RUNNING",
      "backfillAll": {}
    }
    
  12. Mit der Fetch Errors API können Sie alle Fehler abrufen, die mit dem Stream in Verbindung stehen.

    1. Geben Sie an der Eingabeaufforderung den folgenden Befehl ein:

      curl -X POST -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" https://datastream.googleapis.com/[DATASTREAM_API_VERSION]/[PROJECT_PATH]/streams/[STREAM_ID]:fetchErrors
        

    2. Prüfen Sie, ob die folgenden Codezeilen angezeigt werden:

        {
          "name": "[PROJECT_PATH]/operations/operation-[FETCH_ERRORS_OPERATION_ID]",
          "metadata": {
            "@type": "type.googleapis.com/google.cloud.datastream.[DATASTREAM_API_VERSION].OperationMetadata",
            "createTime": "[DATE_AND_TIME_STAMP]",
            "target": "[PROJECT_PATH]/streams/[STREAM_ID]",
            "verb": "fetchErrors",
            "requestedCancellation": false,
            "apiVersion": "[DATASTREAM_API_VERSION]"
          },
          "done": false
        }
        

    3. Geben Sie an der Eingabeaufforderung den folgenden Befehl ein:

      curl -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" https://datastream.googleapis.com/[DATASTREAM_API_VERSION]/[PROJECT_PATH]/operations/operation-[FETCH_ERRORS_OPERATION_ID]
        

    4. Prüfen Sie, ob die folgenden Codezeilen angezeigt werden:

        {
          "name": "[PROJECT_PATH]/operations/operation-[FETCH_ERRORS_OPERATION_ID]",
          "metadata": {
            "@type": "type.googleapis.com/google.cloud.datastream.[DATASTREAM_API_VERSION].OperationMetadata",
            "createTime": "[DATE_AND_TIME_STAMP]",
            "endTime": "[DATE_AND_TIME_STAMP]",
            "target": "[PROJECT_PATH]/streams/[STREAM_ID]",
            "verb": "fetchErrors",
            "requestedCancellation": false,
            "apiVersion": "[DATASTREAM_API_VERSION]"
          },
          "done": true,
          "response": {
            "@type": "type.googleapis.com/google.cloud.datastream.[DATASTREAM_API_VERSION].FetchErrorsResponse"
          }
        }
        

  13. Den Stream anhalten Anleitung:

    1. Ändern Sie die Variable UPDATE. Geben Sie an der Eingabeaufforderung den folgenden Befehl ein:

      UPDATE="{\"state\":\"PAUSED\"}"
      
    2. Geben Sie dann den folgenden Befehl ein:

      curl -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" https://datastream.googleapis.com/[DATASTREAM_API_VERSION]/[PROJECT_PATH]/streams/[STREAM_ID]?updateMask=state
      
  14. Prüfen Sie, ob die folgenden Codezeilen angezeigt werden.

    {
      "name": "[PROJECT_PATH]/operations/operation-[STREAM_OPERATION_ID]",
      "metadata": {
        "@type": "type.googleapis.com/google.cloud.datastream.[DATASTREAM_API_VERSION].OperationMetadata",
        "createTime": "[DATE_AND_TIME_STAMP]",
        "target": "[PROJECT_PATH]/streams/[STREAM_ID]",
        "verb": "start",
        "requestedCancellation": false,
        "apiVersion": "[DATASTREAM_API_VERSION]"
      },
      "done": false
    }
    
  15. Informationen zum Stream abrufen, um zu bestätigen, dass er pausiert ist

    curl -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" https://datastream.googleapis.com/[DATASTREAM_API_VERSION]/[PROJECT_PATH]/streams/[STREAM_ID]
    
  16. Prüfen Sie, ob der Status des Streams von RUNNING zu PAUSED geändert wurde.

    {
      "name": "[PROJECT_PATH]/streams/[STREAM_ID]",
      "createTime": "[DATE_AND_TIME_STAMP]",
      "updateTime": "[DATE_AND_TIME_STAMP]",
      "displayName": "[DISPLAY_NAME]",
      "sourceConfig": {
        "sourceConnectionProfileName": "projects/[YOUR_PROJECT_NUMBER]/locations/[YOUR_PROJECT_LOCATION]/connectionProfiles/[SOURCE_CONNECTION_PROFILE_ID]",
        "oracleSourceConfig": {
          "allowlist": {
            "oracleSchemas": [
              {
                "schemaName": "ROOT"
              }
            ]
          },
          "rejectlist": {}
        }
      },
      "destinationConfig": {
        "destinationConnectionProfileName": "projects/[YOUR_PROJECT_NUMBER]/locations/[YOUR_PROJECT_LOCATION]/connectionProfiles/[DESTINATION_CONNECTION_PROFILE_ID]",
        "gcsDestinationConfig": {
          "fileRotationMb": 100,
          "fileRotationInterval": "15s"
          "avroFileFormat": {}
        }
      },
      "state": "PAUSED",
      "backfillAll": {}
    }
    
  17. Pausiere den pausierten Stream. Anleitung:

    1. Ändern Sie die Variable UPDATE. Geben Sie an der Eingabeaufforderung den folgenden Befehl ein:

      UPDATE="{\"state\":\"RUNNING\"}"
      
    2. Geben Sie dann den folgenden Befehl ein:

      curl -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" https://datastream.googleapis.com/[DATASTREAM_API_VERSION]/[PROJECT_PATH]/streams/[STREAM_ID]?updateMask=state
      
  18. Prüfen Sie, ob die folgenden Codezeilen angezeigt werden.

    {
      "name": "[PROJECT_PATH]/operations/operation-[STREAM_OPERATION_ID]",
      "metadata": {
        "@type": "type.googleapis.com/google.cloud.datastream.[DATASTREAM_API_VERSION].OperationMetadata",
        "createTime": "[DATE_AND_TIME_STAMP]",
        "target": "[PROJECT_PATH]/streams/[STREAM_ID]",
        "verb": "start",
        "requestedCancellation": false,
        "apiVersion": "[DATASTREAM_API_VERSION]"
      },
      "done": false
    }
    
  19. Rufen Sie nach einigen Sekunden Informationen zum Stream ab, um zu prüfen, ob er wieder aktiv ist.

    curl -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" https://datastream.googleapis.com/[DATASTREAM_API_VERSION]/[PROJECT_PATH]/streams/[STREAM_ID]
    
  20. Prüfen Sie, ob der Stream-Status von PAUSED zurück zu RUNNING geändert wurde.

    {
      "name": "[PROJECT_PATH]/streams/[STREAM_ID]",
      "createTime": "[DATE_AND_TIME_STAMP]",
      "updateTime": "[DATE_AND_TIME_STAMP]",
      "displayName": "[DISPLAY_NAME]",
      "sourceConfig": {
        "sourceConnectionProfileName": "projects/[YOUR_PROJECT_NUMBER]/locations/[YOUR_PROJECT_LOCATION]/connectionProfiles/[SOURCE_CONNECTION_PROFILE_ID]",
        "oracleSourceConfig": {
          "allowlist": {
            "oracleSchemas": [
              {
                "schemaName": "ROOT"
              }
            ]
          },
          "rejectlist": {}
        }
      },
      "destinationConfig": {
        "destinationConnectionProfileName": "projects/[YOUR_PROJECT_NUMBER]/locations/[YOUR_PROJECT_LOCATION]/connectionProfiles/[DESTINATION_CONNECTION_PROFILE_ID]",
        "gcsDestinationConfig": {
          "fileRotationMb": 100,
          "fileRotationInterval": "15s"
          "avroFileFormat": {}
        }
      },
      "state": "RUNNING",
      "backfillAll": {}
    }
    

Nachdem Sie einen Stream erstellt und verwaltet haben und bestätigt wurde, dass mit dem Stream keine Fehler verbunden sind und der Status RUNNING ist, können Sie prüfen, ob er Daten aus der Quelldatenbank in ein -Ordner im Cloud Storage-Ziel-Bucket.

Stream prüfen

Bei diesem Verfahren bestätigen Sie Folgendes für Datastream:

  • Überträgt die Daten aller Tabellen, die mit dem Schema ROOT Ihrer Oracle-Quelldatenbank verknüpft sind, in den Ordner /root/tutorial im Cloud Storage-Ziel-Bucket.
  • Er übersetzt die Daten in das Avro-Dateiformat.
  1. Rufen Sie in Cloud Storage die Seite Storage-Browser auf.

    Storage-Browser aufrufen

  2. Klicken Sie auf den Link mit dem Bucket.

  3. Falls der Tab OBJEKTE nicht aktiv ist, klicken Sie darauf.

  4. Klicken Sie auf den Stammordner root und dann auf den Ordner tutorial.

  5. Prüfen Sie, ob die Ordner, die Tabellen des ROOT-Schemas Ihrer Oracle-Quelldatenbank darstellen, angezeigt werden.

  6. Klicken Sie auf einen der Tabellenordner und schlüsseln Sie die Daten auf, bis Sie die mit der Tabelle verknüpften Daten sehen.

  7. Klicken Sie auf eine Datei mit den Daten und dann auf HERUNTERLADEN.

  8. Öffnen Sie diese Datei in einem Avro-Tool (z. B. Avro Viewer), um sicherzustellen, dass der Inhalt gelesen werden kann. So können Sie bestätigen, dass Datastream die Daten außerdem in das Avro-Dateiformat übersetzt hat.

Bereinigen

Nachdem Sie diese Anleitung abgeschlossen haben, können Sie die auf Datastream erstellten Ressourcen bereinigen, damit sie keine kostenpflichtigen Kontingente verbrauchen. In den folgenden Abschnitten wird erläutert, wie Sie diese Ressourcen löschen oder deaktivieren.

Projekt löschen

Am einfachsten vermeiden Sie weitere Kosten durch Löschen des für die Anleitung erstellten Projekts.

So löschen Sie das Projekt:

  1. Wechseln Sie in der Cloud Console zur Seite Ressourcen verwalten.

    Zur Seite „Ressourcen verwalten“

  2. Wählen Sie in der Projektliste das Projekt aus, das Sie löschen möchten, und klicken Sie dann auf Löschen.
  3. Geben Sie im Dialogfeld die Projekt-ID ein und klicken Sie auf Shut down (Beenden), um das Projekt zu löschen.

Cloud Storage-Ziel-Bucket löschen

  1. Klicken Sie in der linken Navigationsleiste von Cloud Storage auf das Element Browser.

  2. Klicken Sie auf das Kästchen links neben dem Bucket und dann auf LÖSCHEN.

  3. Im Bucket löschen? Geben Sie den Namen des Buckets in das Textfeld ein und klicken Sie auf BESTÄTIGEN.

Stream löschen

  1. Prüfen Sie, ob Ihre Cloud Shell-Anwendung aktiv ist.

  2. Geben Sie an der Eingabeaufforderung den folgenden Befehl ein:

    curl -X DELETE -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" https://datastream.googleapis.com/[DATASTREAM_API_VERSION]/[PROJECT_PATH]/streams/[STREAM_ID]
    
  3. Prüfen Sie, ob die folgenden Codezeilen angezeigt werden:

    {
      "name": "[PROJECT_PATH]/operations/operation-[STREAM_OPERATION_ID]",
      "metadata": {
        "@type": "type.googleapis.com/google.cloud.datastream.[DATASTREAM_API_VERSION].OperationMetadata",
        "createTime": "[DATE_AND_TIME_STAMP]",
        "target": "[PROJECT_PATH]/streams/[STREAM_ID]",
        "verb": "delete",
        "requestedCancellation": false,
        "apiVersion": "[DATASTREAM_API_VERSION]"
      },
      "done": false
    }
    
  4. Prüfen Sie, ob der Stream gelöscht wurde. Geben Sie an der Eingabeaufforderung den folgenden Befehl ein:

    curl -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" https://datastream.googleapis.com/[DATASTREAM_API_VERSION]/[PROJECT_PATH]/streams
    
  5. Prüfen Sie, ob der Nullwert {} zurückgegeben wird. Das bedeutet, dass keine Datastreams mehr vorhanden sind und der von Ihnen erstellte Stream gelöscht wird.

Verbindungsprofile löschen

  1. Löschen Sie das Verbindungsprofil in die Oracle-Quelldatenbank. Geben Sie an der Eingabeaufforderung den folgenden Befehl ein:

    curl -X DELETE -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" https://datastream.googleapis.com/[DATASTREAM_API_VERSION]/[PROJECT_PATH]/connectionProfiles/[SOURCE_CONNECTION_PROFILE_ID]
    
  2. Prüfen Sie, ob die folgenden Codezeilen angezeigt werden:

    {
      "name": "[PROJECT_PATH]/operations/operation-[SOURCE_CONNECTION_PROFILE_OPERATION_ID]",
      "metadata": {
        "@type": "type.googleapis.com/google.cloud.datastream.[DATASTREAM_API_VERSION].OperationMetadata",
        "createTime": "[DATE_AND_TIME_STAMP]",
        "target": "[PROJECT_PATH]/connectionProfiles/[SOURCE_CONNECTION_PROFILE_ID]",
        "verb": "delete",
        "requestedCancellation": false,
        "apiVersion": "[DATASTREAM_API_VERSION]"
      },
      "done": false
    }
    
  3. Löschen Sie das Verbindungsprofil zum Ziel-Bucket in Cloud Storage. Geben Sie an der Eingabeaufforderung den folgenden Befehl ein:

    curl -X DELETE -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" https://datastream.googleapis.com/[DATASTREAM_API_VERSION]/[PROJECT_PATH]/connectionProfiles/[DESTINATION_CONNECTION_PROFILE_ID]
    
  4. Prüfen Sie, ob die folgenden Codezeilen angezeigt werden:

    {
      "name": "[PROJECT_PATH]/operations/operation-[DESTINATION_CONNECTION_PROFILE_OPERATION_ID]",
      "metadata": {
        "@type": "type.googleapis.com/google.cloud.datastream.[DATASTREAM_API_VERSION].OperationMetadata",
        "createTime": "[DATE_AND_TIME_STAMP]",
        "target": "[PROJECT_PATH]/connectionProfiles/[DESTINATION_CONNECTION_PROFILE_ID]",
        "verb": "delete",
        "requestedCancellation": false,
        "apiVersion": "[DATASTREAM_API_VERSION]"
      },
      "done": false
    }
    
  5. Prüfen Sie, ob beide Verbindungsprofile gelöscht wurden. Geben Sie an der Eingabeaufforderung den folgenden Befehl ein:

    curl -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" https://datastream.googleapis.com/[DATASTREAM_API_VERSION]/[PROJECT_PATH]/connectionProfiles
    
  6. Prüfen Sie, ob der Nullwert {} zurückgegeben wird. Das bedeutet, dass in Datastream keine Verbindungsprofile mehr vorhanden sind und die von Ihnen erstellten Profile gelöscht werden.

Nächste Schritte