Utilizzo delle API DataStream

Datastream

Per le aziende con molte origini dati isolate, l'accesso ai dati aziendali in tutta l'organizzazione, soprattutto in tempo reale, può essere difficile. Il risultato è un mondo di accesso ai dati limitato e lento, che impedisce all'organizzazione di eseguire l'introspezione.

Datastream fornisce l'accesso quasi in tempo reale ai dati modificati da una serie di origini dati on-premise e basate sul cloud per creare l'accesso ai dati dell'organizzazione. Datastream fornisce un'API di consumo unificata che democratizza l'accesso dell'organizzazione ai dati aziendali più recenti disponibili in tutta l'organizzazione, consentendo scenari integrati quasi in tempo reale.

Uno di questi scenari è il trasferimento di dati da un database di origine a un servizio di archiviazione o a una coda di messaggistica basati sul cloud e la trasformazione di questi dati in un formato leggibile da altre applicazioni e servizi che comunicano con questo servizio di archiviazione o questa coda di messaggistica.

In questo tutorial, imparerai a utilizzare Datastream per trasferire schemi, tabelle e dati da un database Oracle di origine a una cartella in un bucket Cloud Storage. Cloud Storage è un servizio web per l'archiviazione e l'accesso ai dati su Google Cloud. Il servizio combina le prestazioni e la scalabilità del cloud di Google con funzionalità avanzate di sicurezza e condivisione.

Nell'ambito del trasferimento di queste informazioni in una cartella nel bucket Cloud Storage di destinazione, Datastream le traduce in Avro. Avro è definito da uno schema scritto in JavaScript Object Notation (JSON). Questa traduzione ti consente di leggere i dati di diverse origini dati in modo uniforme.

Imposta le variabili di ambiente

In questa procedura, imposterai le seguenti variabili:

  • $PROJECT: Questa variabile è associata al tuo Google Cloud progetto. Tutte le risorse Google Cloud che assegni e utilizzi devono appartenere a un progetto.
  • $TOKEN: questa variabile è associata a un token di accesso. Il token di accesso fornisce una sessione che Cloud Shell utilizza per eseguire attività in Datastream utilizzando le API REST.
  1. Avvia l'applicazione Cloud Shell.

  2. Dopo aver eseguito l'autenticazione nell'applicazione con il tuo Account Google, inserisci il seguente comando:

    gcloud auth login
    
  3. Nel prompt Do you want to continue (Y/n)?, inserisci Y.

  4. Apri un browser web e copia l'URL nel browser.

  5. Esegui l'autenticazione nell'SDK Google Cloud con il tuo Account Google. Un codice viene visualizzato nella pagina Accedi. Questo codice è il tuo token di accesso.

  6. Copia il token di accesso, incollalo nel parametro Enter verification code: nell'applicazione Cloud Shell e premi Enter.

  7. Al prompt, inserisci PROJECT=\"YOUR_PROJECT_NAME\" per impostare la variabile di ambiente $PROJECT sul tuo progetto Google Cloud.

  8. Al prompt, inserisci gcloud config set project YOUR_PROJECT_NAME per impostare il progetto su cui vuoi lavorare come progetto Google Cloud.

    Il prompt dei comandi viene aggiornato in modo da riflettere il progetto attivo e rispetta questo formato: USERNAME@cloudshell:~ (YOUR_PROJECT_NAME)$

  9. Nel prompt, inserisci TOKEN=$(gcloud auth print-access-token) per recuperare il token di accesso e memorizzarlo come variabile.

  10. Al prompt, inserisci i seguenti comandi per assicurarti che le variabili $PROJECT e $TOKEN siano impostate correttamente:

    • echo $PROJECT
    • echo $TOKEN

Ora che hai impostato le variabili, puoi inviare richieste a Datastream per creare e gestire sia i profili di connessione sia uno stream.

Creare e gestire i profili di connessione

In questa sezione, crea e gestisci i profili di connessione per un database Oracle di origine e un bucket di destinazione in Cloud Storage.

Quando crei questi profili di connessione, crei record che contengono informazioni sul database di origine e sul bucket Cloud Storage di destinazione. Datastream utilizza le informazioni nei profili di connessione per trasferire i dati dal database di origine a una cartella nel bucket di destinazione.

La creazione e la gestione dei profili di connessione include:

  • Creazione di profili di connessione per un database Oracle di origine e un bucket di destinazione in Cloud Storage
  • Recupero delle informazioni su un profilo di connessione
  • Modifica di un profilo di connessione
  • Eseguire una chiamata API di rilevamento sul profilo di connessione Oracle di origine. Questa chiamata ti consente di esaminare il database per visualizzare gli oggetti associati. Questi oggetti includono gli schemi e le tabelle che contengono i dati del database. Quando utilizzi Datastream per configurare un flusso, potresti non voler estrarre tutti gli oggetti dal database, ma solo un sottoinsieme (ad esempio, solo determinate tabelle e schemi del database). Utilizza l'API Discover per trovare (o scoprire) il sottoinsieme di oggetti di database che vuoi estrarre.

Creazione di profili di connessione

In questa procedura, crei due profili di connessione: uno a un database Oracle di origine e un altro a un bucket di destinazione in Cloud Storage.

  1. Crea un profilo di connessione a un database Oracle di origine. Al prompt, inserisci questo comando:
ORACLE="{\"displayName\":\"DISPLAY_NAME\",\"oracle_profile\":{\"hostname\":\"HOSTNAME\",\"username\":\"USERNAME\",\"password\":\"PASSWORD\",\"database_service\":\"DATABASE_SERVICE\",\"port\":"PORT_NUMBER\"},\"no_connectivity\":{}}"
  

Utilizza la seguente tabella per comprendere i valori dei parametri per il database Oracle di origine:

Valore parametroSostituisci con
DISPLAY_NAMEIl nome visualizzato del profilo di connessione al database di origine.
HOSTNAMEIl nome host del server del database di origine.
USERNAMEIl nome utente dell'account per il database di origine (ad esempio, ROOT).
PASSWORDLa password dell'account per il database di origine.
DATABASE_SERVICEIl servizio che garantisce che il database di origine sia protetto e monitorato. Per i database Oracle, il servizio di database è in genere ORCL.
PORT_NUMBERIl numero di porta riservato per il database di origine. Per un database Oracle, il numero di porta è in genere 1521.

  1. Al prompt, inserisci il comando echo $ORACLE | jq per visualizzare il profilo di connessione di origine che hai creato in un testo di facile lettura.

    {
      "displayName": "DISPLAY_NAME",
      "oracle_profile": {
        "hostname": "HOSTNAME",
        "username": "USERNAME",
        "password": "PASSWORD",
        "database_service": "DATABASE_SERVICE",
        "port": PORT_NUMBER
       },
      "no_connectivity": {}
    }
  2. Invia il profilo di connessione Oracle in modo che possa essere creato. Al prompt, inserisci questo comando:

    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

    Utilizza la seguente tabella per comprendere i valori dei parametri per questo comando:

    Valore parametroSostituisci con
    DATASTREAM_API_VERSIONLa versione attuale dell'API Datastream (ad esempio v1).
    PROJECT_PATHIl percorso completo del tuo progetto Google Cloud (ad esempio, projects/$PROJECT/locations/YOUR_PROJECT_LOCATION).
    SOURCE_CONNECTION_PROFILE_IDL'identificatore univoco riservato a questo profilo di connessione (ad esempio, cp-1).
  3. Verifica di visualizzare le seguenti righe di codice:

    {
      "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
    }
  4. Crea un profilo di connessione a un bucket di destinazione in Cloud Storage. Al prompt, inserisci questo comando:

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

    Utilizza la seguente tabella per comprendere i valori dei parametri per il bucket di destinazione:

    Valore parametroSostituisci con
    DISPLAY_NAMEIl nome visualizzato del profilo di connessione al bucket di destinazione.
    BUCKET_NAMEIl nome del bucket di destinazione.
    FOLDER_PATHLa cartella nel bucket di destinazione in cui Datastream trasferirà i dati dal database di origine (ad esempio, /root/path).
  5. Al prompt, inserisci il comando echo $GOOGLECLOUDSTORAGE | jq per visualizzare il profilo di connessione di destinazione che hai creato in un testo di facile lettura.

    {
      "displayName": "DISPLAY_NAME",
      "gcs_profile": {
        "bucket_name": "BUCKET_NAME",
        "root_path": "/FOLDER_PATH"
      },
      "no_connectivity": {}
    }
  6. Invia il profilo di connessione Cloud Storage in modo che possa essere creato. Al prompt, inserisci questo comando:

    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
  7. Verifica di visualizzare le seguenti righe di codice:

    {
      "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/DATASTREAM_VERSION/PROJECT_PATH/connectionProfiles/DESTINATION_CONNECTION_PROFILE_ID",
        "verb": "create",
        "requestedCancellation": false,
        "apiVersion": "DATASTREAM_API_VERSION"
      },
      "done": false
    }
  8. Conferma che entrambi i profili di connessione siano stati creati. Al prompt, inserisci questo comando:

    curl -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" https://datastream.googleapis.com/DATASTREAM_API_VERSION/PROJECT_PATH/connectionProfiles
  9. Verifica di ricevere due risultati restituiti per i profili di connessione di origine e di destinazione.

    {
      "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": {}
        }
      ]
    }

Gestione dei profili di connessione

In questa procedura, gestisci i profili di connessione che hai creato per un database Oracle di origine e un bucket di destinazione in Cloud Storage. È incluso quanto segue:

  • Recupero delle informazioni sul profilo di connessione Cloud Storage di destinazione
  • Modifica di questo profilo di connessione. Per questo tutorial, cambierai la cartella del bucket Cloud Storage di destinazione in /root/tutorial. Datastream trasferisce i dati dal database di origine a questa cartella.
  • Esecuzione di una chiamata API Discover sul profilo di connessione Oracle di origine
  1. Recupera le informazioni sul profilo di connessione Cloud Storage di destinazione. Al prompt, inserisci questo comando:

    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. Verifica di visualizzare le informazioni su questo profilo di connessione.

    {
      "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. Modifica questo profilo di connessione. Per farlo, imposta prima una variabile UPDATE. Questa variabile contiene i valori del profilo di connessione che vuoi modificare. Per questo tutorial, modificherai la cartella del bucket di destinazione in /root/tutorial.

    Per impostare la variabile, al prompt, inserisci questo comando:

    UPDATE="{\"gcsProfile\":{\"rootPath\":\"/root/tutorial\"}}"
  4. Al prompt, inserisci questo comando:

    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. Verifica di visualizzare le seguenti righe di codice:

    {
      "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. Conferma che il profilo di connessione sia stato modificato. Al prompt, inserisci questo comando:

    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. Verifica che la cartella del bucket di destinazione del profilo di connessione Cloud Storage ora sia /root/tutorial.

    {
      "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. Utilizza l'API Datastream Discover per scoprire gli schemi e le tabelle del database Oracle di origine. Datastream fornisce l'accesso a questo database tramite il profilo di connessione di origine.

    1. Scopri gli schemi del database Oracle. Al prompt, inserisci questo comando:

      curl -X POST -d "{\"connection_profile_name\":\"projects/YOUR_PROJECT_NUMBER/locations/YOUR_PROJECT_LOCATION/connectionProfiles/SOURCE_CONNECTION_PROFILE_ID\", \"oracle_rdbms\":{\"oracleSchemas\":[{\"schema\":\"ROOT\"}]}}" -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" https://datastream.googleapis.com/DATASTREAM_API_VERSION/PROJECT_PATH/connectionProfiles:discover
    2. Verifica che Datastream recuperi tutti gli schemi del database.

    3. Recupera le tabelle di uno schema nel database. Per questo tutorial, utilizzerai l'API Discover per recuperare le tabelle dello schema ROOT. Tuttavia, puoi scoprire le tabelle di qualsiasi schema nel tuo database.

      Al prompt, inserisci questo comando:

    curl -X POST -d "{\"connection_profile_name\":\"projects/YOUR_PROJECT_NUMBER/locations/YOUR_PROJECT_LOCATION/connectionProfiles/SOURCE_CONNECTION_PROFILE_ID\", \"oracle_rdbms\":{\"oracleSchemas\":[{\"schema\":\"ROOT\"}]}}" -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" https://datastream.googleapis.com/DATASTREAM_API_VERSION/PROJECT_PATH/connectionProfiles:discover
    1. Verifica che Datastream recuperi tutte le tabelle dello schema specificato (per questo tutorial, lo schema ROOT).

Ora che hai creato e gestito i profili di connessione per un database Oracle di origine e un bucket di destinazione in Cloud Storage, puoi creare e gestire uno stream in Datastream.

Creazione e gestione di uno stream

In questa sezione, creerai e gestirai uno stream. Datastream utilizza questo stream per trasferire dati, schemi e tabelle dal database di origine a una cartella nel bucket Cloud Storage di destinazione.

La creazione e la gestione di uno stream include:

  • Convalida di un flusso per assicurarsi che venga eseguito correttamente e che tutti i controlli di convalida vengano superati. Questi controlli includono:
    • Se l'origine è configurata correttamente per consentire a Datastream di trasmettere in streaming i dati.
    • Se lo stream può connettersi sia all'origine che alla destinazione.
    • La configurazione end-to-end dello stream.
  • Creazione dello stream con i seguenti elenchi:
    • Una lista consentita. Questo elenco specifica le tabelle e gli schemi nel database di origine che Datastream può trasferire in una cartella nel bucket di destinazione in Cloud Storage. Per questo tutorial, si tratta della cartella /root/tutorial.
    • Un elenco di rifiuto. Questo elenco specifica le tabelle e gli schemi nel database di origine che Datastream non può trasferire nella cartella del bucket di destinazione Cloud Storage.
  • Recupero delle informazioni sullo stream
  • Modifica dello stream
  • Avvio dello stream in modo che Datastream possa trasferire dati, schemi e tabelle dal database di origine a una cartella nel bucket Cloud Storage di destinazione.
  • Utilizzo dell'API Fetch Errors per rilevare eventuali errori associati allo stream
  • Messa in pausa dello streaming. Quando un flusso viene messo in pausa, Datastream non estrae nuovi dati dal database di origine nel bucket di destinazione.
  • Riprendere lo stream in pausa in modo che Datastream possa continuare a trasferire i dati nel bucket di destinazione.

Crea uno stream

In questa procedura, crei uno stream dal database Oracle di origine a una cartella nel bucket Cloud Storage di destinazione. Il flusso che crei includerà sia una lista consentita che una lista rifiutata.

  1. Imposta una variabile SCHEMAS. Questa variabile definisce gli schemi che contengono i dati e le tabelle che vuoi che Datastream recuperi dal database di origine e trasferisca nella cartella /root/tutorial del bucket di destinazione Cloud Storage. Per questo tutorial, imposterai la variabile SCHEMAS in modo che sia associata allo schema ROOT.

    Al prompt, inserisci questo comando:

    SCHEMAS="{\"oracleSchemas\":[{\"schema\":\"ROOT\"}]}"
  2. Al prompt, inserisci il comando echo $SCHEMAS | jq per visualizzare lo schema ROOT che hai definito per questa variabile in un testo di facile lettura.

  3. Creare uno stream. Al prompt, inserisci questo comando:

    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. Al prompt, inserisci il comando echo $STREAM | jq per visualizzare il flusso creato in un testo di facile lettura.

    {
      "display_name": "DISPLAY_NAME",
      "source_config": {
        "source_connection_profile_name": "PROJECT_PATH/connectionProfiles/SOURCE_CONNECTION_PROFILE_ID",
        "oracle_source_config": {
          "allowlist": {
            "oracleSchemas": [
              {
                "schema": "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": {}
    }

    Utilizza questa tabella per comprendere i seguenti parametri dello stream:

    ParametroDescrizione
    allowlistGli schemi, contenenti tabelle e dati, che verranno trasferiti dal database di origine in una cartella del bucket di destinazione Cloud Storage. Per questo tutorial, tutte le tabelle e i dati dello schema ROOT (e solo questo schema) verranno trasferiti nella cartella /root/tutorial del bucket di destinazione.
    rejectlistTutti gli schemi, contenenti tabelle e dati, che non verranno trasferiti in una cartella del bucket di destinazione Cloud Storage. Per questo tutorial, il valore {} indica che il trasferimento di tabelle e dati dal database di origine al bucket di destinazione non verrà impedito.
    file_rotation_mbLe dimensioni (in MB) dei file che contengono i dati trasferiti dal database di origine a una cartella nel bucket Cloud Storage di destinazione. Per questo tutorial, i dati vengono recuperati dal database di origine e scritti in file da 5 MB. Se i dati superano queste dimensioni, verranno segmentati in più file da 5 MB.
    file_rotation_intervalIl numero di secondi che trascorreranno prima che Datastream chiuda un file esistente in una cartella del bucket di destinazione Cloud Storage e ne apra un altro per contenere i dati trasferiti dal database di origine. Per questo tutorial, l'intervallo di rotazione dei file è impostato su 15 secondi.
    avro_file_format

    Il formato dei file che Datastream trasferirà dal database di origine a una cartella del bucket di destinazione Cloud Storage. Per questo tutorial, Avro è il formato file.

    backfill_all

    Questo parametro è associato al backfill storico. Se imposti questo parametro su un dizionario vuoto ({}), Datastream eseguirà il backfill:

    • I dati storici, oltre alle modifiche in corso ai dati, dal database di origine alla destinazione.
    • Schemi e tabelle, dall'origine alla destinazione.
  5. Convalida lo stream per assicurarti che venga eseguito correttamente e che tutti i controlli di convalida vengano superati. Al prompt, inserisci questo comando:

    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. Verifica di visualizzare la riga di codice {}. Ciò indica che lo stream ha superato tutti i controlli di convalida e che non sono presenti errori associati.

  7. Invia lo stream in modo che possa essere creato. Al prompt, inserisci questo comando:

    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. Verifica di visualizzare le seguenti righe di codice:

    {
      "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. Conferma che lo stream sia stato creato. Al prompt, inserisci questo comando:

    curl -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" https://datastream.googleapis.com/DATASTREAM_API_VERSION/PROJECT_PATH/streams
  10. Verifica di ricevere un risultato restituito per lo stream che hai creato.

    {
      "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": [
                  {
                    "schema": "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": {}
        }
      ]
    }

Gestire lo stream

In questa procedura, utilizzi lo stream che hai creato per trasferire i dati da un database Oracle di origine a una cartella in un bucket di destinazione Cloud Storage. È incluso quanto segue:

  • Recupero delle informazioni sullo stream
  • Modifica dello stream
  • Avvio dello streaming
  • Utilizzo dell'API Fetch Errors per rilevare eventuali errori associati allo stream
  • Mettere in pausa e riprendere lo streaming
  1. Recupera informazioni sullo stream. Al prompt, inserisci questo comando:

    curl -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" https://datastream.googleapis.com/DATASTREAM_API_VERSION/PROJECT_PATH/streams/STREAM_ID
  2. Verifica di visualizzare le informazioni relative a questo stream.

    {
      "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": [
              {
                "schema": "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. Modifica questo flusso. Per farlo, imposta prima una variabile UPDATE. Questa variabile contiene i valori dello stream che vuoi modificare. Per questo tutorial, modifica le dimensioni (in MB) dei file che contengono i dati trasferiti dal database di origine a una cartella nel bucket di destinazione Cloud Storage (da 5 MB a 100 MB). Man mano che i dati vengono recuperati dal database di origine, vengono scritti in file da 100 MB. Se i dati superano questa dimensione, verranno segmentati in più file da 100 MB.

    Per impostare la variabile, al prompt, inserisci questo comando:

    UPDATE="{\"destination_config\":{\"gcs_destination_config\":{\"file_rotation_mb\":100}}}"
  4. Al prompt, inserisci questo comando:

    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. Verifica di visualizzare le seguenti righe di codice:

    {
      "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. Conferma che lo stream sia stato modificato. Al prompt, inserisci questo comando:

    curl -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" https://datastream.googleapis.com/DATASTREAM_API_VERSION/PROJECT_PATH/streams/STREAM_ID
  7. Verifica che il valore del parametro fileRotationMb per il profilo di connessione Cloud Storage sia ora 100.

    {
      "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": [
              {
                "schema": "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. Avvia lo stream. Ecco come fare:

    1. Modifica la variabile UPDATE. Al prompt, inserisci questo comando:

      UPDATE="{\"state\":\"RUNNING\"}"
    2. Quindi, inserisci il seguente comando:

      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. Verifica di visualizzare le seguenti righe di codice.

    {
      "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. Dopo alcuni minuti, recupera le informazioni sul flusso per verificare che sia stato avviato:

    curl -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" https://datastream.googleapis.com/DATASTREAM_API_VERSION/PROJECT_PATH/streams/STREAM_ID
  11. Verifica che lo stato dello stream sia cambiato da CREATED a RUNNING.

    {
      "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": [
              {
                "schema": "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. Utilizzo dell'API Fetch Errors per recuperare eventuali errori associati allo stream.

    1. Al prompt, inserisci questo comando:

      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. Verifica di visualizzare le seguenti righe di codice:

        {
          "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. Al prompt, inserisci questo comando:

      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. Verifica di visualizzare le seguenti righe di codice:

        {
          "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. Metti in pausa lo stream. Ecco come fare:

    1. Modifica la variabile UPDATE. Al prompt, inserisci questo comando:

      UPDATE="{\"state\":\"PAUSED\"}"
    2. Quindi, inserisci il seguente comando:

      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. Verifica di visualizzare le seguenti righe di codice.

    {
      "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. Recupera le informazioni sullo stream per verificare che sia in pausa.

    curl -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" https://datastream.googleapis.com/DATASTREAM_API_VERSION/PROJECT_PATH/streams/STREAM_ID
  16. Verifica che lo stato dello stream sia cambiato da RUNNING a PAUSED.

    {
      "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": [
              {
                "schema": "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. Riprendi lo stream in pausa. Ecco come fare:

    1. Modifica la variabile UPDATE. Al prompt, inserisci questo comando:

      UPDATE="{\"state\":\"RUNNING\"}"
    2. Quindi, inserisci il seguente comando:

      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. Verifica di visualizzare le seguenti righe di codice.

    {
      "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. Dopo alcuni secondi, recupera le informazioni sullo stream per verificare che sia di nuovo in esecuzione.

    curl -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" https://datastream.googleapis.com/DATASTREAM_API_VERSION/PROJECT_PATH/streams/STREAM_ID
  20. Verifica che lo stato dello stream sia passato da PAUSED a RUNNING.

    {
      "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": [
              {
                "schema": "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": {}
    }

Ora che hai creato e gestito uno stream, hai confermato che non ci sono errori associati allo stream e che lo stato dello stream è RUNNING, puoi verificare che possa trasferire i dati dal database di origine in una cartella del bucket Cloud Storage di destinazione.

Verifica dello stream

In questa procedura, confermi che Datastream:

  • Trasferisce i dati da tutte le tabelle associate allo schema ROOT del database Oracle di origine nella cartella /root/tutorial del bucket di destinazione Cloud Storage.
  • Converte i dati nel formato di file Avro.
  1. Vai alla pagina Browser di archiviazione in Cloud Storage.

    Vai alla pagina Browser di archiviazione

  2. Fai clic sul link contenente il bucket.

  3. Se la scheda OGGETTI non è attiva, fai clic.

  4. Fai clic sulla cartella root, quindi sulla cartella tutorial.

  5. Verifica che siano visualizzate cartelle che rappresentano le tabelle dello schema ROOT del database Oracle di origine.

  6. Fai clic su una delle cartelle delle tabelle e visualizza in dettaglio fino a quando non vedi i dati associati alla tabella.

  7. Fai clic su un file che rappresenta i dati e poi su SCARICA.

  8. Apri questo file in uno strumento Avro (ad esempio Avro Viewer) per assicurarti che i contenuti siano leggibili. Ciò conferma che Datastream ha anche convertito i dati nel formato file Avro.