Eseguire la migrazione di schema e dati da Teradata

La combinazione di BigQuery Data Transfer Service e di un agente speciale per la migrazione ti consente di copiare i dati da un'istanza di data warehouse on-premise Teradata a BigQuery. Questo documento descrive la procedura passo passo per eseguire la migrazione dei dati da Teradata utilizzando BigQuery Data Transfer Service.

Prima di iniziare

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

   Roles required to select or create a project

   • Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
   • Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

   Go to project selector

2. Verify that billing is enabled for your Cloud de Confiance project.

3. Enable the BigQuery, BigQuery Data Transfer Service, Cloud Storage, and Pub/Sub APIs.

   Roles required to enable APIs

   To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

   Enable the APIs

4. Create a service account:

   1. Ensure that you have the Create Service Accounts IAM role (roles/iam.serviceAccountCreator) and the Project IAM Admin role (roles/resourcemanager.projectIamAdmin). Learn how to grant roles.

   2. In the Cloud de Confiance console, go to the Create service account page.

      Go to Create service account
   3. Select your project.

   4. In the Service account name field, enter a name. The Cloud de Confiance console fills in the Service account ID field based on this name.

      In the Service account description field, enter a description. For example, Service account for quickstart.

   5. Click Create and continue.

   6. Grant the following roles to the service account: roles/bigquery.user, roles/storage.objectAdmin, roles/iam.serviceAccountTokenCreator.

      To grant a role, find the Select a role list, then select the role.

      To grant additional roles, click add Add another role and add each additional role.

   7. Click Continue.

   8. Click Done to finish creating the service account.

      Do not close your browser window. You will use it in the next step.

5. Create a service account key:

   1. In the Cloud de Confiance console, click the email address for the service account that you created.
   2. Click Keys.
   3. Click Add key, and then click Create new key.
   4. Click Create. A JSON key file is downloaded to your computer.
   5. Click Close.

Impostare le autorizzazioni richieste

Assicurati che l'entità che crea il trasferimento disponga dei seguenti ruoli nel progetto contenente il job di trasferimento:

• Visualizzatore log (roles/logging.viewer)
• Amministratore Storage (roles/storage.admin) o un ruolo personalizzato che concede le seguenti autorizzazioni:
  • storage.objects.create
  • storage.objects.get
  • storage.objects.list
• Amministratore BigQuery (roles/bigquery.admin) o un ruolo personalizzato che concede le seguenti autorizzazioni:
  • bigquery.datasets.create
  • bigquery.jobs.create
  • bigquery.jobs.get
  • bigquery.jobs.listAll
  • bigquery.tables.get
  • bigquery.transfers.get
  • bigquery.transfers.update

Crea un set di dati

Crea un set di dati BigQuery per archiviare i dati. Non devi creare tabelle.

Crea un bucket Cloud Storage

Crea un bucket Cloud Storage per lo staging dei dati durante il job di trasferimento.

Prepara l'ambiente locale

Completa le attività descritte in questa sezione per preparare l'ambiente locale per il job di trasferimento.

Requisiti del computer locale

• L'agente di migrazione utilizza una connessione JDBC con l'istanza Teradata e le API. Assicurati che l'accesso alla rete non sia bloccato da un firewall. Cloud de Confiance by S3NS
• Assicurati che sia installato Java Runtime Environment 8 o versioni successive.
• Assicurati di avere spazio di archiviazione sufficiente per il metodo di estrazione che hai scelto, come descritto in Metodo di estrazione.
• Se hai deciso di utilizzare l'estrazione Teradata Parallel Transporter (TPT), assicurati che l'utilità tbuild sia installata. Per ulteriori informazioni sulla scelta di un metodo di estrazione, consulta Metodo di estrazione.

Dettagli della connessione Teradata

• Assicurati di disporre del nome utente e della password di un utente Teradata con accesso in lettura alle tabelle di sistema e alle tabelle di cui viene eseguita la migrazione.

• Assicurati di conoscere il nome host e il numero di porta per connetterti all'istanza Teradata.

Scarica il driver JDBC

Scarica il file del driver JDBC terajdbc4.jar da Teradata su una macchina che può connettersi al data warehouse.

Imposta la variabile GOOGLE_APPLICATION_CREDENTIALS

Imposta la variabile di ambiente GOOGLE_APPLICATION_CREDENTIALS sulla chiave del account di servizio che hai scaricato nella sezione Prima di iniziare.

Aggiorna la regola di uscita dei Controlli di servizio VPC

Aggiungi il progetto Cloud de Confiance by S3NS gestito da BigQuery Data Transfer Service corrispondente alla tua regione alla regola di uscita nel perimetro Controlli di servizio VPC.

La tabella seguente è un elenco dei numeri di progetto per le località regionali utilizzate per i trasferimenti di dati. Aggiungi i numeri di progetto corrispondenti alla posizione del set di dati.

Località multiregionali

Località regionali

Il canale di comunicazione tra l'agente in esecuzione on-premise e BigQuery Data Transfer Service avviene tramite la pubblicazione di messaggi Pub/Sub in un argomento per trasferimento. BigQuery Data Transfer Service deve inviare comandi all'agente per estrarre i dati e l'agente deve pubblicare messaggi in BigQuery Data Transfer Service per aggiornare lo stato e restituire le risposte all'estrazione dei dati.

Crea un file di schema personalizzato

Per utilizzare un file di schema personalizzato anziché il rilevamento automatico dello schema, creane uno manualmente o fai in modo che l'agente di migrazione ne crei uno per te quando inizializzi l'agente.

Se crei un file di schema manualmente e intendi utilizzare la console Cloud de Confiance per creare un trasferimento, carica il file di schema in un bucket Cloud Storage nello stesso progetto che prevedi di utilizzare per il trasferimento.

Scarica l'agente di migrazione

Scarica l'agente di migrazione su una macchina che può connettersi al data warehouse. Sposta il file JAR dell'agente di migrazione nella stessa directory del file JAR del driver JDBC di Teradata.

Configurare il file delle credenziali per il modulo di accesso

Se utilizzi il modulo di accesso per Cloud Storage con l'utilità Teradata Parallel Transporter (TPT) per l'estrazione, è necessario un file delle credenziali.

Prima di creare un file delle credenziali, devi creare una account di servizio account. Dal file della chiave del account di servizio scaricato, ottieni le seguenti informazioni:

• client_email
• private_key : copia tutti i caratteri all'interno di -----BEGIN PRIVATE KEY----- e -----END PRIVATE KEY-----, inclusi tutti i caratteri /n e senza le doppie virgolette di chiusura.

Una volta ottenute le informazioni richieste, crea un file delle credenziali. Di seguito è riportato un esempio di file delle credenziali con una posizione predefinita di $HOME/.gcs/credentials:

[default]
gcs_access_key_id = ACCESS_ID
gcs_secret_access_key = ACCESS_KEY

Sostituisci quanto segue:

• ACCESS_ID: l'ID chiave di accesso o il valore client_email nel file della chiave del account di servizio.
• ACCESS_KEY: la chiave di accesso segreta o il valore private_key nel file della chiave del account di servizio.

Configurare un trasferimento

Crea un trasferimento con BigQuery Data Transfer Service.

Se vuoi che venga creato automaticamente un file di schema personalizzato, utilizza l'agente di migrazione per configurare il trasferimento.

Non puoi creare un trasferimento on demand utilizzando lo strumento a riga di comando bq. Devi utilizzare la console Cloud de Confiance o l'API BigQuery Data Transfer Service.

Se crei un trasferimento ricorrente, ti consigliamo vivamente di specificare un file di schema in modo che i dati dei trasferimenti successivi possano essere partizionati correttamente quando vengono caricati in BigQuery. Senza un file schema, BigQuery Data Transfer Service deduce lo schema della tabella dai dati di origine trasferiti e tutte le informazioni su partizionamento, clustering, chiavi primarie e monitoraggio delle modifiche vengono perse. Inoltre, i trasferimenti successivi saltano le tabelle di cui è stata eseguita la migrazione in precedenza dopo il trasferimento iniziale. Per saperne di più su come creare un file schema, consulta File schema personalizzato.

bq mk \
--transfer_config \
--project_id=project ID \
--target_dataset=dataset \
--display_name=name \
--service_account_name=service_account \
--params='parameters' \
--data_source=data source

bq mk \
--transfer_config \
--project_id=123456789876 \
--target_dataset=MyDataset \
--display_name='My Migration' \
--params='{"bucket": "mybucket", "database_type": "Teradata",
"database_name":"mydatabase", "table_name_patterns": ".*",
"agent_service_account":"myemail@mydomain.com", "schema_file_path":
"gs://mybucket/myschemafile.json", "is_direct_gcs_unload_enabled": true}' \
--data_source=on_premises

import com.google.api.gax.rpc.ApiException;
import com.google.cloud.bigquery.datatransfer.v1.CreateTransferConfigRequest;
import com.google.cloud.bigquery.datatransfer.v1.DataTransferServiceClient;
import com.google.cloud.bigquery.datatransfer.v1.ProjectName;
import com.google.cloud.bigquery.datatransfer.v1.TransferConfig;
import com.google.protobuf.Struct;
import com.google.protobuf.Value;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;

// Sample to create a teradata transfer config.
public class CreateTeradataTransfer {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    final String projectId = "MY_PROJECT_ID";
    String datasetId = "MY_DATASET_ID";
    String databaseType = "Teradata";
    String bucket = "cloud-sample-data";
    String databaseName = "MY_DATABASE_NAME";
    String tableNamePatterns = "*";
    String serviceAccount = "MY_SERVICE_ACCOUNT";
    String schemaFilePath = "/your-schema-path";
    Map<String, Value> params = new HashMap<>();
    params.put("database_type", Value.newBuilder().setStringValue(databaseType).build());
    params.put("bucket", Value.newBuilder().setStringValue(bucket).build());
    params.put("database_name", Value.newBuilder().setStringValue(databaseName).build());
    params.put("table_name_patterns", Value.newBuilder().setStringValue(tableNamePatterns).build());
    params.put("agent_service_account", Value.newBuilder().setStringValue(serviceAccount).build());
    params.put("schema_file_path", Value.newBuilder().setStringValue(schemaFilePath).build());
    TransferConfig transferConfig =
        TransferConfig.newBuilder()
            .setDestinationDatasetId(datasetId)
            .setDisplayName("Your Teradata Config Name")
            .setDataSourceId("on_premises")
            .setParams(Struct.newBuilder().putAllFields(params).build())
            .setSchedule("every 24 hours")
            .build();
    createTeradataTransfer(projectId, transferConfig);
  }

  public static void createTeradataTransfer(String projectId, TransferConfig transferConfig)
      throws IOException {
    try (DataTransferServiceClient client = DataTransferServiceClient.create()) {
      ProjectName parent = ProjectName.of(projectId);
      CreateTransferConfigRequest request =
          CreateTransferConfigRequest.newBuilder()
              .setParent(parent.toString())
              .setTransferConfig(transferConfig)
              .build();
      TransferConfig config = client.createTransferConfig(request);
      System.out.println("Cloud teradata transfer created successfully :" + config.getName());
    } catch (ApiException ex) {
      System.out.print("Cloud teradata transfer was not created." + ex.toString());
    }
  }
}

Inizializzare l'agente di migrazione

Per un nuovo trasferimento, devi inizializzare l'agente di migrazione. L'inizializzazione è richiesta una sola volta per un trasferimento, indipendentemente dal fatto che sia ricorrente o meno. L'inizializzazione configura solo l'agente di migrazione, non avvia il trasferimento.

Se utilizzerai l'agente di migrazione per creare un file di schema personalizzato, assicurati di avere una directory scrivibile nella directory di lavoro con lo stesso nome del progetto che vuoi utilizzare per il trasferimento. Qui l'agente di migrazione crea il file di schema. Ad esempio, se lavori in /home e configuri il trasferimento nel progetto myProject, crea la directory /home/myProject e assicurati che sia scrivibile dagli utenti.

1. Apri una nuova sessione. Nella riga di comando, esegui il comando di inizializzazione, che segue questo formato:

   java -cp \
   OS-specific-separated-paths-to-jars (JDBC and agent) \
   com.google.cloud.bigquery.dms.Agent \
   --initialize

   L'esempio seguente mostra il comando di inizializzazione quando i file JAR del driver JDBC e dell'agente di migrazione si trovano in una directory migration locale:

   Unix, Linux, Mac OS

   java -cp \
   /usr/local/migration/terajdbc4.jar:/usr/local/migration/mirroring-agent.jar \
   com.google.cloud.bigquery.dms.Agent \
   --initialize

   Windows

   Copia tutti i file nella cartella C:\migration (o modifica i percorsi nel comando), poi esegui:

   java -cp C:\migration\terajdbc4.jar;C:\migration\mirroring-agent.jar com.google.cloud.bigquery.dms.Agent --initialize

2. Quando richiesto, configura le seguenti opzioni:

   1. Scegli se salvare il modello Teradata Parallel Transporter (TPT) su disco. Se prevedi di utilizzare il metodo di estrazione TPT, puoi modificare il modello salvato con i parametri adatti alla tua istanza Teradata.
   2. Digita il percorso di una directory locale che il job di trasferimento può utilizzare per l'estrazione dei file. Assicurati di avere lo spazio di archiviazione minimo consigliato come descritto in Metodo di estrazione.
   3. Digita il nome host del database.
   4. Digita la porta del database.
   5. Scegli se utilizzare Teradata Parallel Transporter (TPT) come metodo di estrazione.
   6. (Facoltativo) Digita il percorso di un file delle credenziali del database.

   7. Scegli se specificare un nome di configurazione di BigQuery Data Transfer Service.

      Se stai inizializzando l'agente di migrazione per un trasferimento che hai già configurato, procedi nel seguente modo:

      1. Digita il nome della risorsa del trasferimento. Puoi trovarlo nella scheda Configurazione della pagina Dettagli trasferimento per il trasferimento.
      2. Quando richiesto, digita un percorso e un nome file per il file di configurazione dell'agente di migrazione che verrà creato. Fai riferimento a questo file quando esegui l'agente di migrazione per avviare il trasferimento.
      3. Ignora i passaggi rimanenti.

      Se utilizzi l'agente di migrazione per configurare un trasferimento, premi Invio per passare al prompt successivo.

   8. Digita l'ID progetto Cloud de Confiance by S3NS .

   9. Digita il nome del database di origine in Teradata.

   10. Digita un pattern per la corrispondenza dei nomi delle tabelle nel database di origine. Puoi utilizzare le espressioni regolari per specificare il pattern. Ad esempio:

       • sales|expenses corrisponde alle tabelle denominate sales e expenses.
       • .* corrisponde a tutte le tabelle.

   11. (Facoltativo) Digita il percorso di un file di schema JSON locale. Questa opzione è vivamente consigliata per i trasferimenti ricorrenti.

       Se non utilizzi un file schema o se vuoi che l'agente di migrazione ne crei uno per te, premi Invio per passare al prompt successivo.

   12. Scegli se creare un nuovo file schema.

       Se vuoi creare un file dello schema:

       1. Digita yes
       2. Digita il nome utente di un utente Teradata che disponga dell'accesso in lettura alle tabelle di sistema e alle tabelle di cui vuoi eseguire la migrazione.

       3. Digita la password per l'utente.

          L'agente di migrazione crea il file dello schema e ne restituisce la posizione.

       4. Modifica il file schema per contrassegnare le colonne di partizionamento, clustering, chiavi primarie e monitoraggio delle modifiche e verifica di voler utilizzare questo schema per la configurazione del trasferimento. Per suggerimenti, consulta File schema personalizzato.

       5. Premi Enter per passare al prompt successivo.

       Se non vuoi creare un file di schema, digita no.

   13. Digita il nome del bucket Cloud Storage di destinazione per la migrazione di gestione temporanea dei dati prima del caricamento in BigQuery. Se l'agente di migrazione ha creato un file di schema personalizzato, questo viene caricato anche in questo bucket.

   14. Digita il nome del set di dati di destinazione in BigQuery.

   15. Digita un nome visualizzato per la configurazione del trasferimento.

   16. Digita un percorso e un nome file per il file di configurazione dell'agente di migrazione che verrà creato.

3. Dopo aver inserito tutti i parametri richiesti, l'agente di migrazione crea un file di configurazione e lo restituisce al percorso locale specificato. Per un'analisi più approfondita del file di configurazione, consulta la sezione successiva.

File di configurazione per l'agente di migrazione

Il file di configurazione creato nel passaggio di inizializzazione è simile a questo esempio:

{
  "agent-id": "81f452cd-c931-426c-a0de-c62f726f6a6f",
  "transfer-configuration": {
    "project-id": "123456789876",
    "location": "us",
    "id": "61d7ab69-0000-2f6c-9b6c-14c14ef21038"
  },
  "source-type": "teradata",
  "console-log": false,
  "silent": false,
  "teradata-config": {
    "connection": {
      "host": "localhost"
    },
    "local-processing-space": "extracted",
    "database-credentials-file-path": "",
    "max-local-storage": "50GB",
    "gcs-upload-chunk-size": "32MB",
    "use-tpt": true,
    "transfer-views": false,
    "max-sessions": 0,
    "spool-mode": "NoSpool",
    "max-parallel-upload": 4,
    "max-parallel-extract-threads": 1,
    "session-charset": "UTF8",
    "max-unload-file-size": "2GB"
  }
}
   

Opzioni del job di trasferimento nel file di configurazione dell'agente di migrazione

• transfer-configuration: informazioni su questa configurazione di trasferimento in BigQuery.

• teradata-config: Informazioni specifiche per questa estrazione di Teradata:

  • connection: Informazioni sull'hostname e sulla porta
  • local-processing-space: la cartella di estrazione in cui l'agente estrarrà i dati della tabella prima di caricarli in Cloud Storage.
  • database-credentials-file-path: (facoltativo) il percorso di un file che contiene le credenziali per la connessione automatica al database Teradata. Il file deve contenere due righe per le credenziali. Puoi utilizzare un nome utente/password, come mostrato nell'esempio seguente:

    username=abc
    password=123

    Puoi anche utilizzare un secret di SecretManager:

    username=abc
    secret_resource_id=projects/my-project/secrets/my-secret-name/versions/1

    Quando utilizzi un file delle credenziali, fai attenzione a controllare l'accesso alla cartella in cui lo memorizzi nel file system locale, perché non è criptato. Se non viene fornito alcun percorso, ti verrà chiesto un nome utente e una password quando avvii un agente.

  • max-local-storage: la quantità massima di spazio di archiviazione locale da utilizzare per l'estrazione nella directory di staging specificata. Il valore predefinito è 50GB. Il formato supportato è: numberKB|MB|GB|TB.

    In tutte le modalità di estrazione, i file vengono eliminati dalla directory di staging locale dopo essere stati caricati in Cloud Storage.

  • use-tpt: indica all'agente di migrazione di utilizzare Teradata Parallel Transporter (TPT) come metodo di estrazione.

    Per ogni tabella, l'agente di migrazione genera uno script TPT, avvia un processo tbuild e attende il completamento. Al termine del processo tbuild, l'agente elenca e carica i file estratti in Cloud Storage, quindi elimina lo script TPT. Per ulteriori informazioni, consulta la sezione Metodo di estrazione.

  • transfer-views: indica all'agente di migrazione di trasferire anche i dati dalle visualizzazioni. Utilizza questa opzione solo quando è necessaria la personalizzazione dei dati durante la migrazione. In altri casi, esegui la migrazione delle viste alle viste BigQuery. Questa opzione presenta i seguenti prerequisiti:

    • Puoi utilizzare questa opzione solo con Teradata versione 16.10 e successive.
    • Una vista deve avere una colonna "partition" di tipo integer definita, che punta a un ID di partizione per la riga specificata nella tabella sottostante.

  • max-sessions: specifica il numero massimo di sessioni utilizzate dal job di estrazione (FastExport o TPT). Se impostato su 0, il database Teradata determinerà il numero massimo di sessioni per ogni job di estrazione.

  • gcs-upload-chunk-size: un file di grandi dimensioni viene caricato in Cloud Storage in blocchi. Questo parametro, insieme a max-parallel-upload, viene utilizzato per controllare la quantità di dati caricati contemporaneamente in Cloud Storage. Ad esempio, se gcs-upload-chunk-size è 64 MB e max-parallel-upload è 10 MB, teoricamente un agente di migrazione può caricare 640 MB (64 MB * 10) di dati contemporaneamente. Se il caricamento del blocco non riesce, è necessario riprovare a caricarlo. La dimensione del chunk deve essere ridotta.

  • max-parallel-upload: questo valore determina il numero massimo di thread utilizzati dall'agente di migrazione per caricare i file in Cloud Storage. Se non specificato, il valore predefinito è il numero di processori disponibili per la macchina virtuale Java. La regola generale è di scegliere il valore in base al numero di core della macchina che esegue l'agente. Quindi, se hai n core, il numero ottimale di thread dovrebbe essere n. Se i core sono hyper-threaded, il numero ottimale dovrebbe essere (2 * n). Esistono anche altre impostazioni, come la larghezza di banda di rete, da considerare durante la regolazione di max-parallel-upload. La regolazione di questo parametro può migliorare le prestazioni di caricamento su Cloud Storage.

  • spool-mode: nella maggior parte dei casi, la modalità NoSpool è l'opzione migliore. NoSpool è il valore predefinito nella configurazione dell'agente. Puoi modificare questo parametro se si applica al tuo caso uno qualsiasi degli svantaggi di NoSpool.

  • max-unload-file-size: determina la dimensione massima del file estratto. Questo parametro non viene applicato per le estrazioni TPT.

  • max-parallel-extract-threads: questa configurazione viene utilizzata solo in modalità FastExport. Determina il numero di thread paralleli utilizzati per estrarre i dati da Teradata. La modifica di questo parametro potrebbe migliorare le prestazioni dell'estrazione.

  • tpt-template-path: utilizza questa configurazione per fornire uno script di estrazione TPT personalizzato come input. Puoi utilizzare questo parametro per applicare le trasformazioni ai dati di migrazione.

  • tpt-export-count: l'operatore di esportazione è responsabile dell'estrazione dei dati dal database Teradata. Questo parametro esegue l'override del conteggio di esportazione predefinito nello script TPT. Deve essere inferiore o uguale al valore del parametro max-sessions per garantire che ogni istanza disponga di un numero sufficiente di pipe al database.

  • tpt-file-writer-count: l'operatore di scrittura dei file è responsabile dell'acquisizione dei dati ricevuti dall'operatore di esportazione e della loro scrittura in un file fisico sul sistema di archiviazione. Questo parametro sostituisce il conteggio predefinito dei writer di file nello script TPT. Idealmente, il numero di scrittori di file deve corrispondere al numero di esportazioni; in caso contrario, il trasferimento diventa un collo di bottiglia all'estrazione o alla fine della scrittura.

  • schema-mapping-rule-path: (facoltativo) il percorso di un file di configurazione che contiene una mappatura dello schema per ignorare le regole di mappatura predefinite. Alcuni tipi di mapping funzionano solo con la modalità Teradata Parallel Transporter (TPT).

    Esempio: mappatura dal tipo Teradata TIMESTAMP al tipo BigQuery DATETIME:

    {
    "rules": [
      {
        "database": {
            "name": "database.*",
            "tables": [
               {
                 "name": "table.*"
               }
            ]
        },
        "match": {
          "type": "COLUMN_TYPE",
          "value": "TIMESTAMP"
        },
        "action": {
          "type": "MAPPING",
          "value": "DATETIME"
        }
      }
    ]
    }

    Attributi:

    • database: (facoltativo) name è un'espressione regolare per i database da includere. Per impostazione predefinita, sono inclusi tutti i database.
    • tables: (facoltativo) contiene un array di tabelle. name è un'espressione regolare per le tabelle da includere. Per impostazione predefinita, sono incluse tutte le tabelle.
    • match: (obbligatorio)
      • Valori supportati per type: COLUMN_TYPE.
      • Valori supportati per value: TIMESTAMP, DATETIME.
    • action: (obbligatorio)
      • Valori supportati per type: MAPPING.
      • Valori supportati per value: TIMESTAMP, DATETIME.

  • compress-output: (facoltativo) indica se i dati devono essere compressi prima di essere archiviati in Cloud Storage. Questa impostazione viene applicata solo in tpt-mode. Per impostazione predefinita, questo valore è false.

  • gcs-module-config-dir: (facoltativo) il percorso del file delle credenziali per accedere al bucket Cloud Storage. La directory predefinita è $HOME/.gcs, ma puoi utilizzare questo parametro per modificare la directory.

  • gcs-module-connection-count: (facoltativo) specifica il numero di connessioni TCP al servizio Cloud Storage. Il valore predefinito è 10.

  • gcs-module-buffer-size: (facoltativo) specifica la dimensione dei buffer da utilizzare per le connessioni TCP. Il valore predefinito è 8 MB (8388608 byte). Per facilità d'uso, puoi utilizzare i seguenti moltiplicatori:

    • k (1000)
    • K (1024)
    • m (1000 * 1000)
    • M (1024*1024)

  • gcs-module-buffer-count: (facoltativo) specifica il numero di buffer da utilizzare con le connessioni TCP specificate da gcs-module-connection-count. Ti consigliamo di utilizzare un valore pari al doppio del numero di connessioni TCP al servizio Cloud Storage. Il valore predefinito è 2 * gcs-module-connection-count.

  • gcs-module-max-object-size: (facoltativo). Questo parametro controlla le dimensioni degli oggetti Cloud Storage. Il valore di questo parametro può essere un numero intero o un numero intero seguito, senza spazi, da uno dei seguenti moltiplicatori:

    • k (1000)
    • K (1024)
    • m (1000 * 1000)
    • M (1024*1024)

  • gcs-module-writer-instances: (facoltativo). Questo parametro specifica il numero di istanze di scrittura di Cloud Storage. Per impostazione predefinita, il valore è 1. Puoi aumentare questo valore per incrementare il throughput durante la fase di scrittura dell'esportazione TPT.

Ottimizzare l'estrazione dei dati degli agenti

Ottimizzando i parametri dell'agente, puoi ottimizzare il processo di estrazione dei dati e rendere efficiente l'intero processo di trasferimento.

La seguente tabella fornisce informazioni sui parametri che puoi utilizzare per ottimizzare la migrazione:

Considera le seguenti best practice per la configurazione:

• Vincolo di memoria: assicurati che il risultato del seguente calcolo sia inferiore alla memoria totale della macchina virtuale (VM) che esegue l'agente. Utilizza unità di misura coerenti per tutti i valori nel calcolo.

  $$ \text{gcs-module-writer-instances} \times \text{gcs-module-buffer-size} \times \text{gcs-module-buffer-count} < \text{Total VM memory} $$

• Ordine di ottimizzazione:

  1. Regola prima il valore parametro gcs-module-writer-instances per trovare il miglior equilibrio tra prestazioni e carico.
  2. Se sono necessari ulteriori miglioramenti del rendimento, aumenta il valore di gcs-module-connection-count.

• Scalabilità automatica: per impostazione predefinita, il valore del parametro gcs-module-buffer-size è in genere impostato sul doppio del conteggio delle connessioni, ma consigliamo di ottimizzare esplicitamente il valore su 32m per questi carichi di lavoro.

Esegui l'agente di migrazione

Dopo aver inizializzato l'agente di migrazione e creato il file di configurazione, segui i passaggi riportati di seguito per eseguire l'agente e avviare la migrazione:

1. Esegui l'agente specificando i percorsi del driver JDBC, dell'agente di migrazione e del file di configurazione creato nel passaggio di inizializzazione precedente.

   java -cp \
   OS-specific-separated-paths-to-jars (JDBC and agent) \
   com.google.cloud.bigquery.dms.Agent \
   --configuration-file=path to configuration file

   Unix, Linux, Mac OS

   java -cp \
   /usr/local/migration/Teradata/JDBC/terajdbc4.jar:mirroring-agent.jar \
   com.google.cloud.bigquery.dms.Agent \
   --configuration-file=config.json

   Windows

   Copia tutti i file nella cartella C:\migration (o modifica i percorsi nel comando), poi esegui:

   java -cp C:\migration\terajdbc4.jar;C:\migration\mirroring-agent.jar com.google.cloud.bigquery.dms.Agent --configuration-file=config.json

   Se vuoi procedere con la migrazione, premi Enter e l'agente procederà se il classpath fornito durante l'inizializzazione è valido.

2. Quando ti viene chiesto, digita il nome utente e la password per la connessione al database. Se il nome utente e la password sono validi, inizia la migrazione dei dati.

   (Facoltativo) Nel comando per avviare la migrazione, puoi anche utilizzare un flag che passa un file di credenziali all'agente, anziché inserire il nome utente e la password ogni volta. Per saperne di più, consulta il parametro facoltativo database-credentials-file-path nel file di configurazione dell'agente. Quando utilizzi un file delle credenziali, adotta le misure appropriate per controllare l'accesso alla cartella in cui lo memorizzi sul file system locale, perché non è criptato.

3. Lascia aperta questa sessione fino al completamento della migrazione. Se hai creato un trasferimento di migrazione ricorrente, mantieni aperta questa sessione a tempo indeterminato. Se questa sessione viene interrotta, le esecuzioni di trasferimento attuali e future non vanno a buon fine.

4. Monitora periodicamente se l'agente è in esecuzione. Se un trasferimento è in corso e nessun agente risponde entro 24 ore, il trasferimento non va a buon fine.

5. Se l'agente di migrazione smette di funzionare durante il trasferimento o la pianificazione, la console Cloud de Confiance mostra lo stato di errore e ti chiede di riavviare l'agente. Per riavviare l'agente di migrazione, torna all'inizio di questa sezione. Non è necessario ripetere il comando di inizializzazione. Il trasferimento riprende dal punto in cui le tabelle non sono state completate.

Monitorare l'avanzamento della migrazione

Puoi visualizzare lo stato della migrazione nella console Cloud de Confiance . Puoi anche configurare notifiche Pub/Sub o email. Consulta Notifiche di BigQuery Data Transfer Service.

BigQuery Data Transfer Service pianifica e avvia un'esecuzione del trasferimento in base a una pianificazione specificata al momento della creazione della configurazione del trasferimento. È importante che l'agente di migrazione sia in esecuzione quando un'esecuzione del trasferimento è attiva. Se non vengono ricevuti aggiornamenti dall'agente entro 24 ore, l'esecuzione del trasferimento non va a buon fine.

Esempio di stato della migrazione nella console Cloud de Confiance :

Esegui l'upgrade dell'agente di migrazione

Se è disponibile una nuova versione dell'agente di migrazione, devi aggiornarlo manualmente. Per ricevere notifiche relative a BigQuery Data Transfer Service, iscriviti alle note di rilascio.

Passaggi successivi

• Prova una migrazione di test da Teradata a BigQuery.
• Scopri di più su BigQuery Data Transfer Service.
• Esegui la migrazione del codice SQL con la traduzione SQL batch.