Utilizzo delle API DataStream

L'API REST Datastream ti consente di replicare in modo programmatico i dati delle modifiche da origini on-premise e cloud in Google Cloud destinazioni per analisi quasi in tempo reale. In questo tutorial creerai profili di connessione e un flusso per replicare schemi, tabelle e dati Oracle in un bucket Cloud Storage. Durante la replica, Datastream converte i record di origine in file Avro con uno schema JSON in modo che le applicazioni downstream possano leggere i dati in modo uniforme tra le origini.

Obiettivi

In questo tutorial imparerai a:

• Imposta le variabili di ambiente. Utilizzerai queste variabili quando effettuerai richieste a Datastream per creare e gestire sia i profili di connessione sia uno stream.
• Crea e gestisci i profili di connessione per un database di origine e un bucket di destinazione in Cloud Storage. Creando questi profili di connessione, crei record che contengono informazioni sul database di origine e sul bucket Cloud Storage di destinazione. Il flusso in Datastream utilizza le informazioni nei profili di connessione per trasferire i dati dal database di origine a una cartella nel bucket di destinazione.
• Creare e gestire uno stream. Datastream utilizza questo stream per trasferire dati, schemi e tabelle dal database di origine a una cartella nel bucket di destinazione.
• Verifica che Datastream trasferisca i dati e le tabelle associati a uno schema del database Oracle di origine in una cartella nel bucket di destinazione e che traduca questi dati nel formato file Avro.
• Esegui la pulizia delle risorse create su Datastream in modo che non occupino quota e non vengano addebitate in futuro.

Costi

In questo documento vengono utilizzati i seguenti componenti fatturabili di Google Cloud:

• Cloud Storage

Per generare una stima dei costi in base all'utilizzo previsto, utilizza il Calcolatore prezzi.

I nuovi utenti di Google Cloud potrebbero avere diritto a una prova senza costi.

Prima di iniziare

1. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

   Roles required to select or create a project

   • Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
   • Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.
   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

2. Verify that billing is enabled for your Google Cloud project.

3. Abilita l'API Datastream.

   Abilita l'API

4. Assicurati che al tuo account utente sia assegnato il ruolo Datastream Admin.

   Vai alla pagina IAM

5. Assicurati di avere un database di origine a cui Datastream possa accedere. Per questo tutorial, viene utilizzato un database Oracle come origine.
6. Configura il database di origine in modo da consentire le connessioni in entrata dagli indirizzi IP pubblici di Datastream. Consulta Liste consentite e regioni IP per accedere alle località di tutte le regioni di Datastream e ai relativi indirizzi IP pubblici associati.
7. Assicurati di aver configurato un bucket Cloud Storage di destinazione a cui Datastream possa accedere utilizzando il metodo di connettività di rete con lista consentita di IP, tunnel SSH di forwarding o peering VPC.
8. Assicurati che nel database di origine siano presenti dati, tabelle e schemi che Datastream può trasferire in una cartella nel bucket Cloud Storage di destinazione.
9. Scarica e installa Cloud Shell. Questa applicazione client fornisce l'accesso tramite riga di comando alle risorse cloud (incluso Datastream).
10. Installa e configura l'utilità jq. Questa utilità è un processore JSON a riga di comando leggero e flessibile. Utilizzerai questo processore per visualizzare comandi cURL complessi in un testo di facile lettura.

Imposta le variabili di ambiente

In questa procedura, imposterai le seguenti variabili:

• $PROJECT: questa variabile è associata al tuo Google Cloud progetto. Eventuali risorseGoogle Cloud allocate e utilizzate 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 all'SDK Google Cloud con il tuo Account Google. Nella pagina Accedi viene visualizzato un codice. Questo codice è il tuo token di accesso.

6. Copia il token di accesso, incollalo nel parametro Enter verification code: nella tua 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 sul tuo progetto Google Cloud.

   Il prompt dei comandi si aggiorna per 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 archiviarlo 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.

Crea e gestisci i profili di connessione

In questa sezione creerai e gestirai 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 includono:

• 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
• Esecuzione di 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 di oggetti (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, creerai due profili di connessione: uno per un database Oracle di origine e un altro per un bucket di destinazione in Cloud Storage.

1. Crea un profilo di connessione a un database Oracle di origine. Al prompt, inserisci il seguente 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 parametro	Sostituisci con
DISPLAY_NAME	Il nome visualizzato del profilo di connessione al database di origine.
HOSTNAME	Il nome host del server del database di origine.
USERNAME	Il nome utente dell'account per il database di origine (ad esempio, ROOT).
PASSWORD	La password dell'account per il database di origine.
DATABASE_SERVICE	Il servizio che garantisce che il database di origine sia protetto e monitorato. Per i database Oracle, il servizio di database è in genere ORCL.
PORT_NUMBER	Il numero di porta riservato al database di origine. Per un database Oracle, il numero di porta è in genere 1521.

Nota: per questo tutorial viene utilizzato il metodo di connessione di rete no_connectivity perché hai configurato il database Oracle di origine in modo da consentire le connessioni in entrata dagli indirizzi IP pubblici di Datastream. Oltre a no_connectivity, sono supportati due metodi di connettività di rete che puoi utilizzare per stabilire una connessione tra il database di origine e la cartella nel bucket Cloud Storage di destinazione.

• Lista consentita di IP: questo metodo funziona configurando il database di origine in modo che accetti connessioni dall'indirizzo IP pubblico di Datastream. Se utilizzi la lista consentita IP come metodo di connessione di rete, sostituisci no_connectivity con StaticIpConnectivity.
• Tunnel SSH di forwarding: questo metodo stabilisce la connettività dal database di origine a Datastream tramite un tunnel SSH sicuro. Se utilizzi il tunnel SSH di forwarding come metodo di connettività di rete, sostituisci no_connectivity con forwardSshTunnelConnectivity. Per informazioni sui valori che puoi impostare per questo metodo di connessione di rete, consulta la documentazione di riferimento.

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 il seguente 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 di questo comando:

   Valore parametro	Sostituisci con
   DATASTREAM_API_VERSION	La versione corrente dell'API Datastream (ad esempio, v1).
   PROJECT_PATH	Il percorso completo del tuo progetto Google Cloud (ad esempio, projects/$PROJECT/locations/YOUR_PROJECT_LOCATION).
   SOURCE_CONNECTION_PROFILE_ID	L'identificatore univoco riservato a questo profilo di connessione (ad esempio, cp-1).

3. Verifica che vengano visualizzate 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
   }

   Nota: il valore parametro SOURCE_CONNECTION_PROFILE_OPERATION_ID è un valore alfanumerico per l'operazione utilizzata per creare questo profilo di connessione. Il valore parametro DATE_AND_TIME_STAMP indica quando viene creato il profilo di connessione e segue il formato YYYY-MM-DDTHH:MM:SSZ.

4. Crea un profilo di connessione a un bucket di destinazione in Cloud Storage. Al prompt, inserisci il seguente comando:

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

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

   Valore parametro	Sostituisci con
   DISPLAY_NAME	Il nome visualizzato del profilo di connessione al bucket di destinazione.
   BUCKET_NAME	Il nome del bucket di destinazione.
   FOLDER_PATH	La 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": "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 il seguente 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

   Importante: per il valore parametro DESTINATION_CONNECTION_PROFILE_ID, assicurati di specificare un identificatore diverso per questo profilo di connessione (ad esempio cp-2).

7. Verifica che vengano visualizzate 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
   }

   Nota: il valore parametro DESTINATION_CONNECTION_PROFILE_OPERATION_ID è un valore alfanumerico per l'operazione utilizzata per creare questo profilo di connessione.

8. Verifica che siano stati creati entrambi i profili di connessione. Al prompt, inserisci il seguente comando:

   curl -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" https://datastream.googleapis.com/DATASTREAM_API_VERSION/PROJECT_PATH/connectionProfiles

   Nota: la stringa connectionProfiles alla fine del comando indica che vuoi recuperare informazioni su entrambi i profili di connessione per confermare che siano stati creati.

9. Verifica di ricevere due risultati 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": {
           "bucket": "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 di rilevamento sul profilo di connessione Oracle di origine

1. Recupera le informazioni sul profilo di connessione Cloud Storage di destinazione. Al prompt, inserisci il seguente 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 che vengano visualizzate 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": {
       "bucket": "BUCKET_NAME",
       "rootPath": "FOLDER_PATH"
     },
     "noConnectivity": {}
   }

3. Modifica questo profilo di connessione. Per farlo, imposta innanzitutto una variabile UPDATE. Questa variabile contiene i valori del profilo di connessione che vuoi modificare. Per questo tutorial, cambierai la cartella del bucket di destinazione in /root/tutorial.

   Per impostare la variabile, inserisci il seguente comando al prompt:

   UPDATE="{\"gcsProfile\":{\"rootPath\":\"/root/tutorial\"}}"

4. Al prompt, inserisci il seguente 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

   Nota: la parte di codice update_mask=gcsProfile.rootPath indica che vuoi modificare il valore del parametro rootPath per il profilo di connessione Cloud Storage.

5. Verifica che vengano visualizzate 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
   }

   Nota: il valore update per il parametro verb indica che hai modificato questo profilo di connessione.

6. Verifica che il profilo di connessione sia stato modificato. Al prompt, inserisci il seguente 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 sia ora /root/tutorial.

   {
     "name": "PROJECT_PATH/connectionProfiles/DESTINATION_CONNECTION_PROFILE_ID",
     "createTime": "DATE_AND_TIME_STAMP",
     "updateTime": "DATE_AND_TIME_STAMP",
     "displayName": "DISPLAY_NAME",
     "gcsProfile": {
       "bucket": "BUCKET_NAME",
       "rootPath": "/root/tutorial"
     },
     "noConnectivity": {}
   }

8. Utilizza l'API Discover di Datastream 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 il seguente 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

      Nota: sostituisci il segnaposto YOUR_PROJECT_NUMBER con il numero di identificazione di 10 cifre del tuo progetto Google Cloud . La parte di codice connectionProfiles:discover indica che vuoi utilizzare il profilo di connessione per il database Oracle di origine per rilevare tutti gli schemi di quel database.

   2. Verifica che Datastream recuperi tutti gli schemi del tuo database.

   3. Recupera le tabelle di uno schema nel tuo 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 il seguente 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 includono:

• Convalida di un flusso per assicurarti 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 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 elementi rifiutati. Questo elenco specifica le tabelle e gli schemi nel database di origine che Datastream non può trasferire nella cartella nel bucket Cloud Storage di destinazione.
• Recupero delle informazioni sullo stream
• Modifica dello stream
• Avviare lo 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
• Metto in pausa lo stream. Quando uno stream è 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. Lo stream che crei includerà sia una lista consentita sia una lista bloccata.

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 Cloud Storage di destinazione. Per questo tutorial, imposterai la variabile SCHEMAS in modo che venga associata allo schema ROOT.

   Al prompt, inserisci il seguente 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 il seguente 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\":{}}}"

   Nota: sostituisci il valore parametro DISPLAY_NAME con il nome visualizzato che vuoi per lo stream (ad esempio, stream1).

4. Al prompt, inserisci il comando echo $STREAM | jq per visualizzare lo stream che hai 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:

   Parametro	Descrizione
   allowlist	Gli schemi, contenenti tabelle e dati, che verranno trasferiti dal database di origine a una cartella del bucket Cloud Storage di destinazione. Per questo tutorial, tutte le tabelle e i dati dello schema ROOT (e solo di questo schema) verranno trasferiti nella cartella /root/tutorial del bucket di destinazione.
   rejectlist	Eventuali schemi, contenenti tabelle e dati, che non verranno trasferiti in una cartella del bucket Cloud Storage di destinazione. Per questo tutorial, il valore {} indica che non verrà impedito il trasferimento di tabelle e dati dal database di origine al bucket di destinazione.
   file_rotation_mb	La dimensione (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 recuperati dal database di origine vengono scritti in file da 5 MB. Se i dati superano queste dimensioni, verranno segmentati in più file da 5 MB.
   file_rotation_interval	Il numero di secondi che trascorreranno prima che Datastream chiuda un file esistente in una cartella del bucket di destinazione Cloud Storage e apra un altro file 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 Cloud Storage di destinazione. Per questo tutorial, il formato file è Avro. Oltre ad Avro, Datastream ora supporta il formato di output JSON per i file scritti in Cloud Storage. Invece di avro_file_format, questo è rappresentato dal parametro json_file_format. Per il formato JSON, puoi: Includi un file di schema tipi unificati nel percorso. Di conseguenza, Datastream scrive due file in Cloud Storage: un file di dati JSON e un file di schema Avro. Il file dello schema ha lo stesso nome del file di dati, con l'estensione .schema. Attiva la compressione gzip per consentire a Datastream di comprimere i file scritti in Cloud Storage. Poiché queste due proprietà non si applicano ad Avro, il valore del parametro avro_file_format è impostato su un dizionario vuoto ({}).
   backfill_all	Questo parametro è associato al backfill storico. Impostando questo parametro su un dizionario vuoto ({}), Datastream eseguirà il backfill: 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 il seguente 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"

   Sostituisci il valore parametro STREAM_ID con un identificatore univoco riservato a questo stream (ad esempio, stream-1).

   Il valore &validate_only=true indica che stai solo convalidando lo stream, non lo stai creando. Per questa richiesta, inserisci l'intero URL tra virgolette. In questo modo, Datastream utilizzerà il valore &validate_only=true per convalidare lo stream.

6. Verifica che sia presente la riga di codice {}. Ciò indica che lo stream ha superato tutti i controlli di convalida e non sono presenti errori associati allo stream.

   Per ogni controllo di convalida non superato, vengono visualizzate informazioni sul motivo dell'errore e su cosa fare per risolvere il problema.

   Dopo aver apportato le correzioni appropriate, effettua nuovamente la richiesta per assicurarti che tutti i controlli di convalida vengano superati.

7. Invia lo stream per crearlo. Al prompt, inserisci il seguente 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 che vengano visualizzate 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
   }

   Nota: il valore parametro STREAM_OPERATION_ID è un valore alfanumerico per l'operazione utilizzata per creare questo stream.

9. Verifica che lo stream sia stato creato. Al prompt, inserisci il seguente comando:

   curl -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" https://datastream.googleapis.com/DATASTREAM_API_VERSION/PROJECT_PATH/streams

   Nota: la stringa streams alla fine del comando indica che vuoi recuperare informazioni sullo stream per confermare che è stato creato.

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

Gestisci lo stream

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

• Recupero delle informazioni sullo stream
• Modifica dello stream
• Avvio dello stream
• Utilizzo dell'API Fetch Errors per rilevare eventuali errori associati allo stream
• Mettere in pausa e riprendere lo stream

1. Recuperare informazioni sullo stream. Al prompt, 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

2. Verifica di visualizzare le informazioni su 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 stream. Per farlo, imposta innanzitutto 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 in una cartella nel bucket Cloud Storage di destinazione (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, inserisci il seguente comando al prompt:

   UPDATE="{\"destination_config\":{\"gcs_destination_config\":{\"file_rotation_mb\":100}}}"

4. Al prompt, inserisci il seguente 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

   Nota: la parte di codice update_mask=destination_config.gcs_destination_config.file_rotation_mb indica che vuoi modificare il valore del parametro file_rotation_mb per il profilo di connessione Cloud Storage.

5. Verifica che vengano visualizzate 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
   }

   Nota: il valore update per il parametro verb indica che hai modificato questo stream.

6. Verifica che lo stream sia stato modificato. Al prompt, 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

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 il seguente comando:

      UPDATE="{\"state\":\"RUNNING\"}"

   2. Poi, 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

      Se utilizzi il parametro updateMask nella richiesta, nel corpo della richiesta devono essere inclusi solo i campi che specifichi.

      In questo esempio, il campo specificato è state, che rappresenta lo stato dello stream. Se avvii lo stream, il suo stato cambia da CREATED a RUNNING.

9. Verifica che vengano visualizzate 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 qualche minuto, recupera le informazioni sullo stream per confermare che è stato avviato:

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

    Nota: l'avvio dello stream richiede alcuni minuti. Le risorse in background devono essere avviate per poter avviare lo stream.

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

    Quando viene avviato uno stream, lo stato cambia prima in STARTING. Ciò significa che lo stream è in fase di avvio e convalida.

    • Se lo stream è valido, il suo stato cambia da STARTING a RUNNING.
    • Se lo stream non è valido, lo stato dello stream torna da STARTING a CREATED. Correggi gli errori relativi allo stream. Ad esempio, se gli errori sono associati alle informazioni di connettività dello stream, modifica la definizione dello stream. Dopo aver risolto tutti i problemi dello stream, riavvialo. Lo stato cambia in STARTING, quindi in RUNNING.

    Se lo stato dello stream è ancora STARTING, attendi qualche secondo e inserisci di nuovo il comando per recuperare le informazioni sullo stream. Lo stato dello stream dovrebbe cambiare in RUNNING.

12. Utilizza l'API Fetch Errors per recuperare eventuali errori associati allo stream.

    1. Al prompt, inserisci il seguente 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 che vengano visualizzate 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
         }
         

       Nota: il valore parametro FETCH_ERRORS_OPERATION_ID è un valore alfanumerico per questa operazione. Utilizzerai questo valore per recuperare le informazioni sull'avanzamento dell'operazione utilizzata per rilevare gli errori associati allo stream.

    3. Al prompt, inserisci il seguente 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 che vengano visualizzate 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"
           }
         }
         

       Nota: non vengono visualizzati errori dopo la riga di codice "@type": "type.googleapis.com/google.cloud.datastream.DATASTREAM_API_VERSION.FetchErrorsResponse. Ciò indica che Datastream non ha rilevato errori per lo stream. Puoi utilizzare lo stream per trasferire i dati dal database Oracle di origine alla cartella /root/tutorial nel bucket Cloud Storage di destinazione. Un esempio di errore che potrebbe essere recuperato utilizzando l'API Fetch Errors è BAD_CREDENTIALS. Questo errore si verifica quando è presente un valore non valido nei profili di connessione di origine o di destinazione e Datastream non può utilizzare i profili per connettersi al database di origine o al bucket di destinazione in Cloud Storage.

13. Mettere in pausa lo stream. Ecco come fare:

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

       UPDATE="{\"state\":\"PAUSED\"}"

    2. Poi, 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

       Se metti in pausa lo stream, il suo stato cambia da RUNNING a PAUSED.

14. Verifica che vengano visualizzate 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 confermare che è 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": {}
    }

    Quando uno stream è in pausa, Datastream non esegue il pull di nuovi dati dal database di origine alla destinazione. Tuttavia, alcuni dati potrebbero continuare a essere scritti nella destinazione perché i dati "in transito" continueranno a fluire.

    Pertanto, dopo aver messo in pausa uno stream, lo stato dello stream cambia da RUNNING a DRAINING. Lo svuotamento di un flusso è il processo di svuotamento del flusso in modo che non contenga dati. Dopo che tutti i dati sono stati svuotati dal flusso, lo stato del flusso cambia da DRAINING a PAUSED.

17. Riprendi lo stream in pausa. Ecco come fare:

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

       UPDATE="{\"state\":\"RUNNING\"}"

    2. Poi, 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

       Se riprendi lo stream, il suo stato cambia da PAUSED a RUNNING.

18. Verifica che vengano visualizzate 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 confermare che è 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 cambiato 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 un flusso, hai confermato che non sono presenti errori associati al flusso e che lo stato del flusso è RUNNING, puoi verificare che possa trasferire i dati dal database di origine a una cartella nel bucket di destinazione di Cloud Storage.

Verifica dello stream

In questa procedura, confermi che Datastream:

• Trasferisce i dati di tutte le tabelle associate allo schema ROOT del database Oracle di origine nella cartella /root/tutorial nel bucket Cloud Storage di destinazione.
• Traduce i dati nel formato file Avro.

1. Vai alla pagina Browser Storage in Cloud Storage.

   Vai alla pagina Browser di Storage

2. Fai clic sul link che contiene il tuo bucket.

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

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

   Nota: Datastream ha creato le cartelle root e tutorial dopo che hai modificato il profilo di connessione di destinazione cambiando la cartella del bucket di destinazione in /root/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 della tabella ed esegui il drill down fino a visualizzare 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 tradotto i dati nel formato file Avro.

Esegui la pulizia

Al termine di questo tutorial, puoi eliminare le risorse che hai creato su Datastream in modo che non occupino quota e non ti vengano addebitate in futuro. Le seguenti sezioni descrivono come eliminare o disattivare queste risorse.

Elimina il progetto

Il modo più semplice per eliminare la fatturazione è eliminare il progetto creato per il tutorial.

Per eliminare il progetto:

Attenzione: l'eliminazione di un progetto ha i seguenti effetti:

• L'intero contenuto del progetto viene eliminato. Se hai utilizzato un progetto esistente per, le attività descritte in questo documento, eliminerai anche tutto il lavoro che hai svolto nel progetto.
• Gli ID progetto personalizzati non sono più disponibili. Quando hai creato questo progetto, potresti aver creato un ID progetto personalizzato che vuoi utilizzare in futuro. Per conservare gli URL che utilizzano l'ID progetto, ad esempio un URL appspot.com, elimina le risorse selezionate all'interno del progetto anziché eliminare l'intero progetto.

Se intendi esplorare più architetture, tutorial o guide rapide, puoi riutilizzare i progetti ed evitare così di superare i limiti di quota.

1. Nella console Google Cloud , vai alla pagina Gestisci risorse.

   Vai a Gestisci risorse

2. Nell'elenco dei progetti, seleziona il progetto che vuoi eliminare, quindi fai clic su Elimina.
3. Nella finestra di dialogo, digita l'ID progetto, quindi fai clic su Chiudi per eliminare il progetto.

Elimina il bucket Cloud Storage di destinazione

1. Nel riquadro di navigazione a scomparsa di Cloud Storage a sinistra, fai clic sulla voce Browser.

2. Seleziona la casella di controllo a sinistra del bucket e fai clic su ELIMINA.

3. Nella finestra Vuoi eliminare il bucket?, inserisci il nome del bucket nel campo di testo e fai clic su CONFERMA.

Elimina lo stream

1. Assicurati che l'applicazione Cloud Shell sia attiva.

2. Al prompt, inserisci il seguente comando:

   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. Verifica che vengano visualizzate 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": "delete",
       "requestedCancellation": false,
       "apiVersion": "DATASTREAM_API_VERSION"
     },
     "done": false
   }

4. Verifica che lo stream sia stato eliminato. Al prompt, inserisci il seguente comando:

   curl -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" https://datastream.googleapis.com/DATASTREAM_API_VERSION/PROJECT_PATH/streams

5. Verifica che venga restituito un valore {} null. Ciò significa che non sono più presenti stream in Datastream e che lo stream che hai creato è stato eliminato.

Elimina i profili di connessione

1. Elimina il profilo di connessione al database Oracle di origine. Al prompt, inserisci il seguente comando:

   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. Verifica che vengano visualizzate 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": "PROJECT_PATH/connectionProfiles/SOURCE_CONNECTION_PROFILE_ID",
       "verb": "delete",
       "requestedCancellation": false,
       "apiVersion": "DATASTREAM_API_VERSION"
     },
     "done": false
   }

3. Elimina il profilo di connessione al bucket di destinazione in Cloud Storage. Al prompt, inserisci il seguente comando:

   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. Verifica che vengano visualizzate 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": "delete",
       "requestedCancellation": false,
       "apiVersion": "DATASTREAM_API_VERSION"
     },
     "done": false
   }

5. Verifica che entrambi i profili di connessione siano stati eliminati. Al prompt, inserisci il seguente comando:

   curl -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" https://datastream.googleapis.com/DATASTREAM_API_VERSION/PROJECT_PATH/connectionProfiles

6. Verifica che venga restituito un valore {} null. Ciò significa che non esistono più profili di connessione in Datastream e che i profili che hai creato sono stati eliminati.

Passaggi successivi

• Scopri di più su Datastream.
• Prova le altre funzionalità di Google Cloud . Dai un'occhiata ai nostri tutorial.