Questa pagina è stata tradotta dall'API Cloud Translation.

Utilizzo delle API DataStream

Datastream

Panoramica

Per le attività con molte origini dati isolate, l'accesso ai dati aziendali in tutta l'organizzazione, soprattutto in tempo reale, può essere difficile. Ne consegue un accesso limitato e lento ai dati, che impedisce 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 offre un'esperienza di configurazione semplice e un'API a consumo unificato che democratizza l'accesso dell'organizzazione ai dati aziendali più aggiornati disponibili al suo interno, favorendo scenari integrati quasi in tempo reale.

Uno di questi scenari è il trasferimento dei dati da un database di origine a un servizio di archiviazione o coda di messaggistica basato su cloud e la loro trasformazione in un modulo leggibile da altre applicazioni e servizi che comunicano con il servizio di archiviazione o la 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 di un bucket Cloud Storage. Cloud Storage è un servizio web per l'archiviazione e l'accesso ai dati su Google Cloud. Il servizio combina le prestazioni e la scalabilità del cloud di Google con funzionalità avanzate di sicurezza e condivisione.

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

Obiettivi

In questo tutorial imparerai a:

Imposta le variabili di ambiente. Utilizzerai queste variabili quando invii 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. La creazione di questi profili di connessione comporta la creazione di 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.
Crea e gestisci uno stream. Datastream utilizza questo flusso per trasferire dati, schemi e tabelle dal database di origine a una cartella del bucket di destinazione.
Verifica che Datastream trasferisca i dati e le tabelle associati a uno schema del database Oracle di origine in una cartella del bucket di destinazione e traduca questi dati nel formato file Avro.
Esegui la pulizia delle risorse che hai creato su Datastream in modo che non occupino la quota e non ti verranno addebitati costi in futuro.

Costi

In questo documento utilizzi i seguenti componenti fatturabili di Google Cloud:

Cloud Storage

Per generare una stima dei costi basata sull'utilizzo previsto, utilizza il Calcolatore prezzi. I nuovi utenti di Google Cloud potrebbero essere idonei per una prova gratuita.

Prima di iniziare

Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

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

Go to project selector

Make sure that billing is enabled for your Google Cloud project.

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

Go to project selector

Make sure that billing is enabled for your Google Cloud project.

Abilita l'API Datastream.
Abilitare l'API
Assicurati che al tuo account utente sia assegnato il ruolo Amministratore Datastream.
Vai alla pagina IAM
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 per consentire le connessioni in entrata dagli indirizzi IP pubblici Datastream. Consulta Liste consentite e regioni IP per accedere alle località di tutte le regioni 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 di IP, il tunnel SSH di inoltro 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 da 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 comandi cURL 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. Tutte le risorse Google 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 utilizzata da Cloud Shell per eseguire attività in Datastream utilizzando le API REST.

Avvia l'applicazione Cloud Shell.
Dopo aver eseguito l'autenticazione nella tua applicazione con il tuo Account Google, inserisci gcloud auth login.
Al prompt di Do you want to continue (Y/n)?, inserisci Y.
Apri un browser web e copia l'URL nel browser.
Esegui l'autenticazione in Google Cloud SDK con il tuo Account Google. Nella pagina Accedi viene visualizzato un codice. Questo codice è il tuo token di accesso.
Copia il token di accesso, incollalo nel parametro Enter verification code: dell'applicazione Cloud Shell e premi Enter.
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 Google Cloud su cui vuoi lavorare.

Il prompt dei comandi si aggiorna in base al progetto attivo e rispetta questo formato: USERNAME@cloudshell:~ (YOUR_PROJECT_NAME)$
Al prompt, inserisci TOKEN=$(gcloud auth print-access-token) per recuperare il token di accesso e memorizzarlo come variabile.
Al prompt, inserisci i comandi seguenti per assicurarti che le variabili $PROJECT e $TOKEN siano impostate correttamente:
- echo $PROJECT
- echo $TOKEN

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

Creare e gestire profili di connessione

In questa sezione creerai e gestirai profili di connessione per un database Oracle di origine e un bucket di destinazione in Cloud Storage.

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

La creazione e la gestione dei profili di connessione include:

Creazione di profili di connessione per un database Oracle di origine e un bucket di destinazione in Cloud Storage
Recupero delle informazioni su un profilo di connessione
Modifica di un profilo di connessione
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 piuttosto un sottoinsieme degli oggetti (ad esempio, solo alcuni schemi e tabelle del database). Utilizza l'API Discover per trovare (o rilevare) il sottoinsieme di oggetti di 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 un altro a un bucket di destinazione in Cloud Storage.

Crea un profilo di connessione a un database Oracle di origine. Al prompt, inserisci il comando seguente:

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 per il database di origine. Per un database Oracle, il numero di porta è in genere 1521.

Nota: per questo tutorial viene utilizzato il metodo di connettività di rete no_connectivity perché hai configurato il database Oracle di origine per consentire le connessioni in entrata dagli indirizzi IP pubblici 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 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 connettività 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 inoltro come metodo di connettività di rete, sostituisci no_connectivity con forwardSshTunnelConnectivity. Per informazioni sui valori che puoi impostare per questo metodo di connettività di rete, consulta la documentazione di riferimento.

Al prompt, inserisci il comando echo $ORACLE | jq per visualizzare il profilo di connessione di origine che hai creato in 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 comando seguente:

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 attuale 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 siano 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 comando seguente:

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

Utilizza la seguente tabella per comprendere i valori parametro 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 vedere il profilo di connessione di destinazione che hai creato in testo di facile lettura.

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

Invia il profilo di connessione Cloud Storage in modo che possa essere creato. Al prompt, inserisci il comando seguente:
```
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).

Verifica che siano 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
}

Verifica che siano stati creati entrambi i profili di connessione. Al prompt, inserisci il comando seguente:
```
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 le informazioni su entrambi i profili di connessione per confermare che sono stati creati.

Verifica che vengano restituiti 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": {
        "bucketName": "BUCKET_NAME",
        "rootPath": "FOLDER_PATH"
      },
      "noConnectivity": {}
    },
   {
    "name": "PROJECT_PATH/connectionProfiles/SOURCE_CONNECTION_PROFILE_ID",
    "createTime": "DATE_AND_TIME_STAMP",
    "updateTime": "DATE_AND_TIME_STAMP",
    "displayName": "DISPLAY_NAME",
    "oracleProfile": {
      "hostname": "HOSTNAME",
      "port": PORT_NUMBER,
      "username": "USERNAME",
      "databaseService": "DATABASE_SERVICE"
    },
    "noConnectivity": {}
    }
  ]
}

Gestione dei profili di connessione

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

Recupero delle informazioni sul profilo di connessione Cloud Storage di destinazione
Modifica di questo profilo di connessione in corso. 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 comando seguente:

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

Per impostare la variabile, inserisci il seguente comando al prompt:
```
UPDATE="{\"gcsProfile\":{\"rootPath\":\"/root/tutorial\"}}"
```

Al prompt, inserisci il comando seguente:

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

{
  "name": "PROJECT_PATH/operations/operation-DESTINATION_CONNECTION_PROFILE_OPERATION_ID",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.datastream.DATASTREAM_API_VERSION.OperationMetadata",
    "createTime": "DATE_AND_TIME_STAMP",
    "target": "PROJECT_PATH/connectionProfiles/DESTINATION_CONNECTION_PROFILE_ID",
    "verb": "update",
    "requestedCancellation": false,
    "apiVersion": "DATASTREAM_API_VERSION"
  },
  "done": false
}

Verifica che il profilo di connessione sia stato modificato. Al prompt, inserisci il comando seguente:

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

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

Utilizza l'API Datastream Discover per scoprire gli schemi e le tabelle del database Oracle di origine. Datastream fornisce l'accesso a questo database tramite il profilo di connessione di origine.
1. Scopri gli schemi del database Oracle. Al prompt, inserisci il comando seguente:
```
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 a 10 cifre del tuo progetto Google Cloud. La porzione connectionProfiles:discover del codice indica che vuoi utilizzare il profilo di connessione per il database Oracle di origine al fine di 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 database. Per questo tutorial, utilizzerai l'API Discover per recuperare le tabelle dello schema ROOT. Tuttavia, puoi trovare 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 un flusso in Datastream.

Creazione e gestione di uno stream

In questa sezione devi 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 include:

Convalida di uno stream 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 dati dal flusso.
- Indica 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 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 che Datastream non può trasferire nella cartella del bucket di destinazione Cloud Storage.
Recupero delle informazioni sullo stream
Modifica dello stream
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 allo stream
Metto in pausa lo stream. Quando un flusso viene messo in pausa, Datastream non esegue il pull di nuovi dati dal database di origine al bucket di destinazione.
Riprendi lo stream in pausa in modo che Datastream possa continuare a trasferire i dati nel bucket di destinazione.

Creazione di un flusso

In questa procedura, creerai un flusso dal database Oracle di origine a una cartella del bucket Cloud Storage di destinazione. Lo stream che crei includerà sia una lista di elementi consentiti sia una lista di elementi rifiutati.

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

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

Creare uno stream. Al prompt, inserisci il comando seguente:

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 creato con 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, tutte le tabelle e tutti i dati dello schema `ROOT` (e solo 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 di destinazione Cloud Storage. 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`	Le dimensioni (in MB) dei file che contengono dati 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, vengono scritti in file da 5 MB. I dati che superano queste dimensioni verranno segmentati in più file da 5 MB.
`file_rotation_interval`	Il numero di secondi che trascorrono prima che Datastream chiuda un file esistente in una cartella del bucket di destinazione Cloud Storage e apra un altro file contenente 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. Oltre ad Avro, Datastream ora supporta il formato di output JSON per i file scritti in Cloud Storage. Invece di `avro_file_format`, è rappresentato dal parametro `json_file_format`. Per il formato JSON, puoi: Includi un file di schema dei 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 di schema ha lo stesso nome del file di dati, con estensione `.schema`. Abilita la compressione gzip per fare in modo che Datastream comprima 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. 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 siano stati superati. Al prompt, inserisci il comando seguente:
```
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 convalidando solo lo stream. non lo stai creando. Per questa richiesta, metti l'intero URL tra virgolette. In questo modo, Datastream acquisirà il valore &validate_only=true per convalidare lo stream.
Verifica che sia visualizzata la riga di codice {}. Questo indica che lo stream ha superato tutti i controlli di convalida e non ci sono errori associati.

In caso di mancato superamento di un controllo di convalida, vengono visualizzate informazioni sul motivo della mancata riuscita e su cosa fare per correggere il problema.

Dopo aver apportato le correzioni del caso, invia nuovamente la richiesta per garantire il superamento di tutti i controlli di convalida.

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

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

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

Verifica che il flusso sia stato creato. Al prompt, inserisci il comando seguente:
```
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 le informazioni sul flusso per confermare che è stato creato.

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 che hai creato per trasferire i dati da un database Oracle di origine a una cartella di un bucket di destinazione Cloud Storage. tra cui:

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 streaming

Recupera le informazioni sul flusso. Al prompt, inserisci il comando seguente:

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. Per farlo, devi prima impostare una variabile UPDATE. Questa variabile contiene i valori dello stream da modificare. Per questo tutorial, modifica le dimensioni (in MB) dei file che contengono dati trasferiti dal database di origine a una cartella nel bucket di destinazione Cloud Storage (da 5 MB a 100 MB). Poiché i dati vengono recuperati dal database di origine, vengono scritti in file da 100 MB. I dati che superano queste dimensioni 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}}}"
```

Al prompt, inserisci il comando seguente:

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 siano 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:
1. Modifica la variabile UPDATE. Al prompt, inserisci il comando seguente:
```
UPDATE="{\"state\":\"RUNNING\"}"
```
2. Quindi, inserisci il seguente comando:
```
curl -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" https://datastream.googleapis.com/DATASTREAM_API_VERSION/PROJECT_PATH/streams/STREAM_ID?updateMask=state
```
  Se utilizzi il parametro updateMask nella richiesta, solo i campi specificati devono essere inclusi nel corpo della richiesta.
  
  In questo esempio, il campo specificato è il campo state, che rappresenta lo stato (o lo stato) del flusso. Se avvii lo stream, ne cambi lo stato da CREATED a RUNNING.

Verifica che siano 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 minuti, recupera le informazioni sullo stream per verificare che sia stato avviato:
```
curl -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" https://datastream.googleapis.com/DATASTREAM_API_VERSION/PROJECT_PATH/streams/STREAM_ID
```
Nota :l'avvio dello stream richiede qualche minuto. Per poter avviare lo stream, le risorse in background devono essere avviate.

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

Utilizzo dell'API Fetch Errors per recuperare eventuali errori associati allo stream.

Al prompt, inserisci il comando seguente:

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 siano 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 siano 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 viene visualizzato alcun errore dopo la riga di codice "@type": "type.googleapis.com/google.cloud.datastream.DATASTREAM_API_VERSION.FetchErrorsResponse. Questo indica che Datastream non ha rilevato errori per il flusso. Puoi utilizzare il flusso per trasferire i dati dal database Oracle di origine alla cartella /root/tutorial del bucket di destinazione Cloud Storage. Un esempio di errore che potrebbe essere recuperato utilizzando l'API Fetch Errore è 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.

Metti in pausa lo stream. Ecco come fare:
1. Modifica la variabile UPDATE. Al prompt, inserisci il comando seguente:
```
UPDATE="{\"state\":\"PAUSED\"}"
```
2. Quindi, inserisci il seguente comando:
```
curl -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" https://datastream.googleapis.com/DATASTREAM_API_VERSION/PROJECT_PATH/streams/STREAM_ID?updateMask=state
```
  Mettendo in pausa lo stream, ne cambi lo stato da RUNNING a PAUSED.

Verifica che siano 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 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

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

Riprendi lo stream in pausa. Ecco come fare:

Modifica la variabile UPDATE. Al prompt, inserisci il comando seguente:
```
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

Se riattivi lo stream, cambi il suo stato da PAUSED a RUNNING.

Verifica che siano 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 venga eseguito di nuovo.

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 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 verificato che non sono presenti errori associati al flusso e che lo stato del flusso è RUNNING, puoi verificare che sia in grado di trasferire i dati dal database di origine a una cartella del 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.
Traduci i dati nel formato file Avro.

Vai alla pagina Browser Storage in Cloud Storage.

Vai alla pagina del browser 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 su quella tutorial.

Nota: Datastream ha creato le cartelle root e tutorial dopo che hai modificato il profilo di connessione di destinazione modificando la cartella del bucket di destinazione in /root/tutorial.
Verifica che siano visualizzate le cartelle che rappresentano le tabelle dello schema ROOT del database Oracle di origine.
Fai clic su una delle cartelle della tabella e visualizza i dettagli fino a quando non vedi 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. Ciò 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 su Datastream in modo che non occupino quota e non ti vengano addebitati costi 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 che hai 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, quando lo elimini elimini anche tutto il lavoro 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 appspot.com URL, elimina le risorse selezionate all'interno del progetto anziché eliminare l'intero progetto.

Se intendi esplorare più architetture, tutorial o guide rapide, il riuso dei progetti può aiutarti a non superare i limiti di quota.

In the Google Cloud console, go to the Manage resources page.
Go to Manage resources
In the project list, select the project that you want to delete, and then click Delete.
In the dialog, type the project ID, and then click Shut down to delete the project.

Elimina il bucket di destinazione Cloud Storage

Nel riquadro 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 Elimina 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 comando seguente:

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 siano 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
}

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

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 indica che non ci sono più flussi in Datastream e che quello che hai creato è stato eliminato.

Elimina i profili di connessione

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

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

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

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. Ciò significa che non ci sono 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.