Panoramica
Per le aziende con molte origini dati isolate, l'accesso ai dati aziendali in tutta l'organizzazione, soprattutto in tempo reale, può risultare difficile. Ciò si traduce in un mondo di accesso ai dati limitato e lento, impedendo all'organizzazione di introspersi.
Datastream fornisce l'accesso quasi in tempo reale per modificare i dati da una varietà di origini dati on-premise e basate su cloud per creare l'accesso ai dati dell'organizzazione. Datastream fornisce un'esperienza di configurazione semplice e un'API a consumo unificato che democratizza l'accesso dell'organizzazione ai dati aziendali più aggiornati disponibili in tutta l'organizzazione, supportando scenari integrati quasi in tempo reale.
Uno di questi scenari consiste nel trasferimento dei dati da un database di origine a un servizio di archiviazione o a una coda di messaggistica basati su cloud, trasformandoli in un modulo leggibile da altre applicazioni e servizi che comunicano con questo servizio di archiviazione o 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.
Durante il trasferimento di queste informazioni in una cartella del bucket Cloud Storage di destinazione, Datastream traduce queste informazioni in Avro. Avro è definito da uno schema scritto in JSON (JavaScript Object Notation). Questa traduzione ti consente di leggere in modo uniforme i dati di diverse origini dati.
Obiettivi
In questo tutorial imparerai a:- Imposta le variabili di ambiente. Utilizzerai queste variabili quando invierai richieste a Datastream per creare e gestire sia i profili di connessione sia uno stream.
- Crea e gestisci profili di connessione per un database di origine e un bucket di destinazione in Cloud Storage. La creazione di questi profili di connessione consente di creare record contenenti 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.
- Crea e gestisci uno stream. Datastream utilizza questo flusso 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 li traduca nel formato file Avro.
- Esegui la pulizia delle risorse che hai creato in Datastream in modo che non occupino quota e non ti vengano addebitati costi 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.
Prima di iniziare
- Accedi al tuo account Google Cloud. Se non conosci Google Cloud, crea un account per valutare le prestazioni dei nostri prodotti in scenari reali. I nuovi clienti ricevono anche 300 $di crediti gratuiti per l'esecuzione, il test e il deployment dei carichi di lavoro.
-
Nella pagina del selettore di progetti della console Google Cloud, seleziona o crea un progetto Google Cloud.
-
Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.
-
Nella pagina del selettore di progetti della console Google Cloud, seleziona o crea un progetto Google Cloud.
-
Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.
- Abilitare l'API Datastream.
- Assicurati di aver assegnato il ruolo Amministratore Datastream al tuo account utente.
- Assicurati di disporre di un database di origine a cui Datastream può accedere. Per questo tutorial, viene utilizzato un database Oracle come origine.
- Configura il database di origine in modo da consentire le connessioni in entrata da indirizzi IP pubblici Datastream. Vedi Liste consentite e regioni IP per accedere alle località di tutte le regioni di Datastream e ai relativi indirizzi IP pubblici associati.
- Assicurati di aver configurato un bucket Cloud Storage di destinazione a cui Datastream può accedere utilizzando la lista consentita IP, il tunnel SSH di forwarding o il metodo di connettività di rete del peering VPC.
- Assicurati che nel database di origine siano presenti dati, tabelle e schemi che Datastream può trasferire in una cartella del bucket Cloud Storage di destinazione.
- Scarica e installa Cloud Shell. Questa applicazione client fornisce l'accesso tramite riga di comando alle risorse cloud (incluso Datastream).
- Installa e configura l'utilità
jq
. Questa utilità è un processore JSON a riga di comando leggero e flessibile. Utilizzerai questo processore per visualizzare comandicURL
complessi in testo di facile lettura.
Imposta le variabili di ambiente
In questa procedura, imposterai le seguenti variabili:
$PROJECT
: questa variabile è associata al tuo progetto Google Cloud. Qualsiasi risorsa Google Cloud che assegni e utilizzi deve 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 mediante le API REST.
Avvia l'applicazione Cloud Shell.
Dopo l'autenticazione nell'applicazione con il tuo Account Google, inserisci
gcloud auth login
.Al prompt di
Do you want to continue (Y/n)?
, inserisciY
.Apri un browser web e copia l'URL al suo interno.
Esegui l'autenticazione in Google Cloud SDK con il tuo Account Google. Viene visualizzato un codice nella pagina Accedi. Questo codice è il tuo token di accesso.
Copia il token di accesso, incollalo nel parametro
Enter verification code:
nell'applicazione Cloud Shell e premiEnter
.Al prompt, inserisci
PROJECT="YOUR_PROJECT_NAME"
per impostare la variabile di ambiente$PROJECT
sul tuo progetto Google Cloud.Al prompt, inserisci
gcloud config set project YOUR_PROJECT_NAME
per impostare il progetto su cui vuoi lavorare nel progetto Google Cloud.Il prompt dei comandi si aggiorna in modo da riflettere il progetto attivo e rispettare questo formato:
USERNAME@cloudshell:~ (YOUR_PROJECT_NAME)$
Al prompt, inserisci
TOKEN=$(gcloud auth print-access-token)
per recuperare il token di accesso e archiviarlo come variabile.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 effettuare richieste a Datastream per creare e gestire sia i profili di connessione sia un flusso.
Creare e gestire 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 contenenti 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 guardare all'interno del database per vedere gli oggetti associati. Questi oggetti includono gli schemi e le tabelle che contengono i dati del database. Quando utilizzi Datastream per configurare un flusso, è possibile che tu non voglia estrarre tutti gli oggetti dal database, ma piuttosto un sottoinsieme di oggetti (ad esempio, solo alcune tabelle e schemi del database). Utilizza l'API Discover per trovare (o scoprire) il sottoinsieme di oggetti del database di cui vuoi eseguire il pull.
Creazione di profili di connessione
In questa procedura creerai due profili di connessione: uno a un database Oracle di origine e l'altro a un bucket di destinazione in Cloud Storage.
- 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, in genere il servizio di database è ORCL. |
PORT_NUMBER | Il numero di porta riservato per il database di origine. Per un database Oracle, il numero di porta è in genere 1521. |
Al prompt, inserisci il comando
echo $ORACLE | jq
per visualizzare il profilo di connessione di origine che hai creato con 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": {} }
Invia il profilo di connessione Oracle in modo da poterlo creare. 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 per questo comando:
Valore parametro Sostituisci con DATASTREAM_API_VERSION La versione corrente dell'API Datastream (ad esempio v1
).PROJECT_PATH Il percorso completo del progetto Google Cloud (ad esempio projects/$PROJECT/locations/YOUR_PROJECT_LOCATION
).SOURCE_CONNECTION_PROFILE_ID L'identificatore univoco riservato per questo profilo di connessione (ad esempio cp-1). 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 } Creare 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_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 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 del bucket di destinazione in cui Datastream trasferirà i dati dal database di origine (ad esempio /root/path). Al prompt, inserisci il comando
echo $GOOGLECLOUDSTORAGE | jq
per visualizzare con testo di facile lettura il profilo di connessione di destinazione che hai creato.{ "displayName": "DISPLAY_NAME", "gcs_profile": { "bucket_name": "BUCKET_NAME", "root_path": "/FOLDER_PATH" }, "no_connectivity": {} }
Invia il profilo di connessione Cloud Storage in modo da poterlo creare. 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 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 } Conferma 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 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, puoi gestire i profili di connessione creati per un database Oracle di origine e un bucket di destinazione in Cloud Storage. Ciò include:
- Recupero delle informazioni sul profilo di connessione Cloud Storage di destinazione
- Modifica di questo profilo di connessione. Per questo tutorial, modificherai 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
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 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": {} }
Modifica questo profilo di connessione. A questo scopo, devi prima impostare una variabile UPDATE. Questa variabile contiene i valori del profilo di connessione da modificare. Per questo tutorial, modificherai la cartella del bucket di destinazione in /root/tutorial.
Per impostare la variabile, inserisci il seguente comando nel prompt:
UPDATE="{\"gcsProfile\":{\"rootPath\":\"/root/tutorial\"}}"
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 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 }
Conferma che il profilo di connessione è 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 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": { "bucketName": "BUCKET_NAME", "rootPath": "/root/tutorial" }, "noConnectivity": {} }
Usa 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.
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 Verifica che Datastream recuperi tutti gli schemi del tuo database.
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 rilevare 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 - Verifica che Datastream recuperi tutte le tabelle dello schema che hai 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 un flusso in Datastream.
Creazione e gestione di uno stream
In questa sezione puoi creare e gestire uno stream. Datastream utilizza questo flusso 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:
- Indica se l'origine è configurata correttamente per consentire a Datastream di trasmettere i flussi di dati dall'origine.
- Indica se il flusso può connettersi sia all'origine che alla destinazione.
- La configurazione end-to-end del flusso.
- Crea lo 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 del bucket di destinazione in Cloud Storage. Per questo tutorial, questa è la cartella /root/tutorial.
- Un elenco di rifiuti. Questo elenco specifica le tabelle e gli schemi nel database di origine a cui Datastream non può trasferire nella cartella del bucket di destinazione Cloud Storage.
- Recupero delle informazioni sullo stream
- Modifica del flusso
- Avvio del flusso 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 al flusso
- Sospensione dello stream. Quando un flusso è in pausa, Datastream non esegue il pull di nuovi dati dal database di origine nel bucket di destinazione.
- Riprendo il flusso in pausa in modo che Datastream possa continuare a trasferire i dati nel bucket di destinazione.
Crea uno stream
In questa procedura, creerai un flusso dal database Oracle di origine in una cartella nel bucket Cloud Storage di destinazione. Lo stream che crei includerà sia una lista consentita sia una lista per i rifiuti.
Imposta una variabile SCHEMAS. Questa variabile definisce gli schemi contenenti i dati e le tabelle che vuoi che Datastream recuperi dal database di origine e vengano trasferiti nella cartella /root/tutorial del bucket di destinazione Cloud Storage. Per questo tutorial, imposterai la variabile SCHEMAS da associare allo schema ROOT.
Al prompt, inserisci il seguente comando:
SCHEMAS="{\"oracleSchemas\":[{\"schema\":\"ROOT\"}]}"
Al prompt, inserisci il comando echo $SCHEMAS | jq per visualizzare lo schema ROOT definito per questa variabile con un testo di facile lettura.
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\":{}}}" Al prompt, inserisci il comando
echo $STREAM | jq
per visualizzare lo stream che hai creato con 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 di destinazione Cloud Storage. Per questo tutorial, tutti i dati e le tabelle dello schema ROOT (e solo questo) 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 di destinazione Cloud Storage. Per questo tutorial, il valore {} indica che a nessuna tabella e a nessun dato del database di origine verrà impedito il trasferimento nel bucket di destinazione. file_rotation_mb Le dimensioni (in MB) dei file contenenti i dati che vengono trasferiti dal database di origine a una cartella nel bucket di destinazione Cloud Storage. Per questo tutorial, i dati vengono recuperati dal database di origine e scritti in file da 5 MB. Se i dati superano queste dimensioni, vengono segmentati in più file da 5 MB. file_rotation_interval Il numero di secondi che trascorrerà prima che Datastream chiuda un file esistente in una cartella del bucket di destinazione Cloud Storage e apra un altro file che contiene 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, il formato file è Avro.
backfill_all Questo parametro è associato al backfill storico. Se imposti 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.
Convalida il flusso 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" Verifica che sia visualizzata la riga di codice
{}
. Questo indica che il flusso ha superato tutti i controlli di convalida e che non ci sono errori associati al flusso.Invia lo stream in modo che possa essere creato. 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 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 }
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 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, utilizzerai il flusso creato per trasferire i dati da un database Oracle di origine a una cartella in un bucket di destinazione Cloud Storage. Ciò include:
- Recupero delle informazioni sullo stream
- Modifica del flusso
- Avvio dello stream
- Utilizzo dell'API Fetch Errors per rilevare eventuali errori associati al flusso
- Mettere in pausa e riprendere lo stream
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 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": {} } Modifica questo stream. A questo scopo, devi prima impostare 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 di destinazione Cloud Storage (da 5 MB a 100 MB). I dati, che vengono recuperati dal database di origine, vengono scritti in file da 100 MB. Se i dati superano queste dimensioni, vengono segmentati in più file da 100 MB.
Per impostare la variabile, inserisci il seguente comando nel prompt:
UPDATE="{\"destination_config\":{\"gcs_destination_config\":{\"file_rotation_mb\":100}}}"
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 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 }
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 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": {} } Avvia lo stream. Ecco come fare:
Modifica la variabile
UPDATE
. Al prompt, inserisci il seguente comando:UPDATE="{\"state\":\"RUNNING\"}"
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
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 }
Dopo qualche minuto, recupera le informazioni sullo stream per verificare che sia iniziato:
curl -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json"
https://datastream.googleapis.com/DATASTREAM_API_VERSION/PROJECT_PATH/streams/STREAM_ID Verifica che lo stato del flusso sia cambiato da
CREATED
aRUNNING
.{ "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": {} } Utilizzo dell'API Fetch Errors per recuperare eventuali errori associati al flusso.
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 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 }
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 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" } }
Metti in pausa lo stream. Ecco come fare:
Modifica la variabile
UPDATE
. Al prompt, inserisci il seguente comando:UPDATE="{\"state\":\"PAUSED\"}"
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
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 }
Recupera le informazioni sullo stream per verificare che sia sospeso.
curl -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json"
https://datastream.googleapis.com/DATASTREAM_API_VERSION/PROJECT_PATH/streams/STREAM_ID Verifica che lo stato del flusso sia cambiato da
RUNNING
aPAUSED
.{ "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": {} } Riprendi lo streaming messo in pausa. Ecco come fare:
Modifica la variabile
UPDATE
. Al prompt, inserisci il seguente comando:UPDATE="{\"state\":\"RUNNING\"}"
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
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 }
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 Verifica che lo stato del flusso sia cambiato da
PAUSED
aRUNNING
.{ "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": {} }
Dopo aver creato e gestito un flusso, verificato che non vi siano errori associati al flusso e che lo stato del flusso sia RUNNING
, puoi verificare che possa trasferire i dati dal database di origine a una cartella nel bucket di destinazione Cloud Storage.
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. - Traduce i dati nel formato file Avro.
Vai alla pagina Browser Storage in Cloud Storage.
Fai clic sul link che contiene il bucket.
Se la scheda OGGETTI non è attiva, fai clic su di essa.
Fai clic sulla cartella principale, quindi sulla cartella tutorial.
Verifica che siano visualizzate cartelle che rappresentano le tabelle dello schema
ROOT
del tuo database Oracle di origine.Fai clic su una delle cartelle della tabella ed esamina in dettaglio i dati associati alla tabella.
Fai clic su un file che rappresenta i dati e poi su SCARICA.
Apri questo file in uno strumento Avro (ad esempio, Avro Viewer) per assicurarti che i contenuti siano leggibili. Questo conferma che Datastream ha anche tradotto i dati nel formato file Avro.
Esegui la pulizia
Al termine di questo tutorial, puoi eseguire la pulizia delle risorse che hai creato in Datastream in modo che non occupino quota e non ti vengano addebitate in futuro. Le sezioni seguenti descrivono come eliminare o disattivare queste risorse.
Elimina il progetto
Il modo più semplice per eliminare la fatturazione è eliminare il progetto che hai creato per il tutorial.
Per eliminare il progetto:
- Nella console Google Cloud, vai alla pagina Gestisci risorse.
- Nell'elenco dei progetti, seleziona il progetto che vuoi eliminare, quindi fai clic su Elimina.
- Nella finestra di dialogo, digita l'ID del progetto e fai clic su Chiudi per eliminare il progetto.
Elimina il bucket di destinazione Cloud Storage
Nel riquadro a scomparsa di navigazione a sinistra di Cloud Storage, fai clic sulla voce Browser.
Seleziona la casella di controllo a sinistra del bucket e fai clic su ELIMINA.
Nella finestra Eliminare il bucket?, inserisci il nome del bucket nel campo di testo e fai clic su CONFERMA.
Elimina lo stream
Assicurati che la tua applicazione Cloud Shell sia attiva.
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 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 }
Conferma che lo stream è 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 Verifica che venga restituito un valore
{}
nullo. Questo significa che non ci sono più stream in Datastream e che quello che hai creato viene eliminato.
Elimina i profili di connessione
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 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 }
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 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 }
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 Verifica che venga restituito un valore
{}
nullo. Questo significa che non ci sono più profili di connessione in Datastream e che i profili che hai creato vengono eliminati.
Passaggi successivi
- Scopri di più su Datastream.
- Prova in prima persona altre funzionalità di Google Cloud. Dai un'occhiata ai nostri tutorial.