Apache Hive-Metastore-Tabellen zuCloud de Confiancemigrieren

In diesem Dokument wird beschrieben, wie Sie Ihre von Apache Hive Metastore verwalteten Iceberg- und Hive-Tabellen mithilfe des BigQuery Data Transfer Service zuCloud de Confiance migrieren.

Mit dem Apache Hive Metastore-Migrationsconnector im BigQuery Data Transfer Service können Sie Ihre Hive Metastore-Tabellen nahtlos und in großem Umfang zu Cloud de Confiance migrieren. Dieser Connector unterstützt sowohl Hive- als auch Iceberg-Tabellen aus lokalen Installationen und Cloud-Umgebungen, einschließlich Cloudera-Einrichtungen. Der Hive Metastore-Migrationsconnector unterstützt Dateien, die in den folgenden Datenquellen gespeichert sind:

• Apache Hadoop Distributed File System (HDFS)
• Amazon Simple Storage Service (Amazon S3)
• Azure Blob Storage oder Azure Data Lake Storage Gen2

Mit dem Hive-Metastore-Migrationsconnector können Sie Cloud Storage als Dateispeicher verwenden und Ihre Hive-Metastore-Tabellen in einem der folgenden Metastore registrieren:

• BigLake Metastore Iceberg REST-Katalog

  Wir empfehlen, den Iceberg REST-Katalog des BigLake Metastore für alle Ihre Iceberg-Daten zu verwenden.

  Der Iceberg REST Catalog des BigLake-Metastore ermöglicht die Interoperabilität zwischen Ihren Abfrage-Engines, da er eine einzige Quelle der Wahrheit für alle Ihre Iceberg-Daten bietet. Sie können BigQuery verwenden, um die Daten abzufragen, zusätzlich zu Apache Spark und anderen OSS-Engines. Der Iceberg REST Catalog von BigLake Metastore unterstützt nur Iceberg-Tabellenformate.

• Dataproc Metastore

  Dataproc Metastore unterstützt sowohl Hive- als auch Iceberg-Tabellenformate. Sie können nur Apache Spark und andere OSS-Engines verwenden, um Daten in Dataproc Metastore zu lesen und zu schreiben.

Dieser Connector unterstützt sowohl vollständige als auch reine Metadatenübertragungen. Bei vollständigen Übertragungen werden sowohl Ihre Daten als auch Ihre Metadaten aus Ihren Quelltabellen in Ihren Ziel-Metastore übertragen. Sie können eine reine Metadatenübertragung erstellen, wenn sich Ihre Daten bereits in Cloud Storage befinden und Sie sie nur in einem Ziel-Metastore registrieren möchten.

Das folgende Diagramm bietet einen Überblick über den Migrationsprozess.

Beschränkungen

Übertragungen von Hive Metastore-Tabellen unterliegen den folgenden Einschränkungen:

• Zwischen zwei geplanten Ausführungen von Hive-Metastore-Übertragungen müssen mindestens 24 Stunden liegen. On-demand-Ausführungen können weiterhin in beliebigen Intervallen ausgelöst werden.
• Wenn Sie Hive-Tabellen migrieren möchten, müssen Sie Dataproc Metastore als Ziel-Metastore verwenden.
• Dateinamen müssen den Anforderungen für die Benennung von Cloud Storage-Objekten entsprechen.
• Für einzelne Objekte in Cloud Storage gilt ein Limit von 5 TiB. Dateien in Ihren Hive-Metastore-Tabellen, die größer als 5 TiB sind, können nicht übertragen werden.
• Storage Transfer Service hat ein bestimmtes Verhalten, wenn Daten in der Quelle geändert werden, während eine Übertragung läuft. Wir raten davon ab, in Tabellen zu schreiben, während sie aktiv migriert werden. Eine Liste der anderen Einschränkungen des Storage Transfer Service finden Sie unter Bekannte Einschränkungen.

Optionen für die Datenaufnahme

In den folgenden Abschnitten finden Sie weitere Informationen zur Konfiguration Ihrer Hive-Metastore-Übertragungen.

Inkrementelle Übertragungen

Wenn eine Übertragungskonfiguration mit einem wiederkehrenden Zeitplan eingerichtet wird, wird die Tabelle auf Cloud de Confiance by S3NS bei jeder nachfolgenden Übertragung mit den neuesten Änderungen an der Quelltabelle aktualisiert. Beispielsweise werden alle Datenaktualisierungen und alle Einfüge-, Lösch- oder Aktualisierungsvorgänge mit Schemaänderungen bei jeder Übertragung in Cloud de Confiance by S3NS berücksichtigt.

Partitionen filtern

Sie können eine Teilmenge von Partitionen aus Ihren Hive-Tabellen übertragen, indem Sie eine benutzerdefinierte Filter-JSON-Datei in Cloud Storage bereitstellen. Geben Sie beim Planen der Übertragung den vollständigen Cloud Storage-Pfad zu dieser JSON-Datei mit dem Parameter partition_filter_gcs_path an.

Im Folgenden sehen Sie ein Beispiel für die Struktur der Filter-JSON-Datei:

{
  "filters": [
    {
      "table": "db1.table1", "condition": "IN", "partition":
      ["partition1=value1/partition2=value2"]
    },
    {
      "table": "db1.table2", "condition": "LESS_THAN", "partition":
      ["partition1;value1"]
    },
    {
      "table": "db1.table3", "condition": "GREATER_THAN", "partition":
      ["partition1;value1"]
    },
    {
      "table": "db1.table4", "condition": "RANGE", "partition":
      ["partition1;value1;value2"]
    }
  ]
}

Filterbedingungen

Das Feld condition in der JSON-Datei unterstützt die folgenden Werte, jeweils mit einem bestimmten Format für das partition-Array:

• IN: Gibt die genauen Partitionspfade an, die eingeschlossen werden sollen. Das Array partition enthält Strings, die die genaue Verzeichnisstruktur der Partitionen relativ zum Tabellenbasispfad darstellen (z. B. ["partition_key1=value1/partition_key2=value2"]). Sie können mehrere Pfade im Array angeben.
• LESS_THAN: Enthält Partitionen, in denen der primäre Partitionsschlüsselwert kleiner oder gleich dem angegebenen Wert ist. Das partition-Array muss einen einzelnen String im Format ["<partition_key>;<value>"] enthalten.
• GREATER_THAN: Enthält Partitionen, in denen der primäre Partitionsschlüsselwert größer oder gleich dem angegebenen Wert ist. Das partition-Array muss einen einzelnen String im Format ["<partition_key>;<value>"] enthalten.
• RANGE: Enthält Partitionen, in denen der primäre Partitions-Schlüsselwert in den angegebenen Bereich fällt (einschließlich). Das partition-Array muss einen einzelnen String im Format ["<partition_key>;<start_value>;<end_value>"] enthalten.

Für die Filterbedingungen gelten die folgenden Regeln und Einschränkungen:

• Einschließlich der Werte:Filterbedingungen für GREATER_THAN, LESS_THAN und RANGE schließen die angegebenen Werte ein. Ein LESS_THAN-Filter mit dem Wert 2023 enthält beispielsweise Partitionen bis einschließlich 2023.
• Löschen von Partitionen:Wenn eine vorhandene Zielpartition dem Partitionsfilter entspricht und in der Quelle nicht mehr vorhanden ist, wird sie aus dem Zielmetastore entfernt. Die zugrunde liegenden Datendateien für diese Partition werden jedoch nicht aus dem Cloud Storage-Ziel-Bucket gelöscht.
• Einschränkungen für einzelne Tabellen:
  • Mehrere Filter für dieselbe Tabelle sind nicht zulässig.
  • Sie können nicht verschiedene Bedingungstypen (z. B. GREATER_THAN und IN) in derselben Tabelle kombinieren.
• Zielpartitionsspalte:Filterbedingungen wie GREATER_THAN, LESS_THAN und RANGE müssen auf die primäre Partitionsspalte ausgerichtet sein.
• Beschränkungen für Präfixe:Die angegebene Filterkombination darf nicht zu mehr als 1.000 Präfixen pro Tabelle führen. Ein Filter wie year>2020 für eine Tabelle, die nach year/month/day partitioniert ist, darf beispielsweise nicht mehr als 1.000 eindeutige year=-Präfixe enthalten.

Hinweis

Bevor Sie die Hive Metastore-Übertragung planen, führen Sie die Schritte in diesem Abschnitt aus.

APIs aktivieren

Aktivieren Sie die folgenden APIs in IhremCloud de Confiance -Projekt:

• Data Transfer API
• Storage Transfer API

Ein Dienst-Agent wird erstellt, wenn Sie die Data Transfer API aktivieren.

Berechtigungen konfigurieren

So konfigurieren Sie Berechtigungen für eine Hive-Metastore-Übertragung:

1. Dem Nutzer oder Dienstkonto, das die Übertragung erstellt, muss die Rolle „BigQuery-Administrator“ (roles/bigquery.admin) zugewiesen werden. Wenn Sie ein Dienstkonto verwenden, wird es nur zum Erstellen der Übertragung verwendet.

2. Beim Aktivieren der Data Transfer API wird ein Dienst-Agent (P4SA) erstellt.

   Bitten Sie Ihren Administrator, dem Dienst-Agent die folgenden IAM-Rollen für das Projekt zuzuweisen, damit der Dienst-Agent die erforderlichen Berechtigungen zum Ausführen einer Hive-Metastore-Übertragung hat:

   • Storage Transfer-Administrator (roles/storagetransfer.admin)
   • Service Usage Consumer (roles/serviceusage.serviceUsageConsumer)
   • Storage-Administrator (roles/storage.admin)
   • So migrieren Sie Metadaten in den BigLake Metastore Iceberg REST-Katalog: BigLake-Administrator (roles/biglake.admin)
   • So migrieren Sie Metadaten zu Dataproc Metastore: Dataproc Metastore-Dateninhaber (roles/metastore.metadataOwner)

   Weitere Informationen zum Zuweisen von Rollen finden Sie unter Zugriff auf Projekte, Ordner und Organisationen verwalten.

   Ihr Administrator kann dem Dienst-Agent möglicherweise auch die erforderlichen Berechtigungen über benutzerdefinierte Rollen oder andere vordefinierte Rollen erteilen.

3. Wenn Sie ein Dienstkonto verwenden, weisen Sie dem Dienst-Agent mit dem folgenden Befehl die Rolle roles/iam.serviceAccountTokenCreator zu:

   gcloud iam service-accounts add-iam-policy-binding
   SERVICE_ACCOUNT --member
   serviceAccount:service-PROJECT_NUMBER@gcp-sa-bigquerydatatransfer.s3ns-system.iam.gserviceaccount.com --role
   roles/iam.serviceAccountTokenCreator

4. Weisen Sie dem Storage Transfer Service-Dienst-Agent (project-PROJECT_NUMBER@storage-transfer-service.s3ns-system.iam.gserviceaccount.com) die folgenden Rollen im Projekt zu:

   • roles/storage.admin
   • Wenn Sie von On-Premise/HDFS migrieren, müssen Sie auch die Rolle roles/storagetransfer.serviceAgent zuweisen.

   Sie können auch detailliertere Berechtigungen konfigurieren. Weitere Informationen finden Sie in diesem Leitfaden:

   • HDFS-Berechtigungen
   • Amazon S3- und Microsoft Azure-Berechtigungen

Metadatendatei für Apache Hive generieren

Führen Sie das dwh-migration-dumper-Tool aus, um Metadaten für Apache Hive zu extrahieren. Das Tool generiert eine Datei mit dem Namen hive-dumper-output.zip, die in einen Cloud Storage-Bucket hochgeladen werden kann. Dieser Cloud Storage-Bucket wird in diesem Dokument als DUMPER_BUCKET bezeichnet.

Sie können auch regelmäßige Uploads mit einem Skript planen. Weitere Informationen finden Sie unter Ausführung des Dumper-Tools mit einem cron-Job automatisieren.

Storage Transfer Service konfigurieren

Wählen Sie eine der folgenden Optionen aus:

Hive-Metastore-Übertragung planen

Wählen Sie eine der folgenden Optionen aus:

  bq mk --transfer_config
  --data_source=hadoop display_name='TRANSFER_NAME'
  --service_account_name='SERVICE_ACCOUNT'
  --project_id='PROJECT_ID' location='REGION'
  --params='{
    "transfer_strategy":"TRANSFER_STRATEGY",
    "table_name_patterns":"LIST_OF_TABLES",
    "table_metadata_path":"gs://DUMPER_BUCKET/hive-dumper-output.zip",
    "target_gcs_file_path":"gs://MIGRATION_BUCKET",
    "metastore":"METASTORE",
    "destination_dataproc_metastore":"DATAPROC_METASTORE_URL",
    "destination_bigquery_dataset":"BIGLAKE_METASTORE_DATASET",
    "translation_output_gcs_path":"gs://TRANSLATION_OUTPUT_BUCKET/metadata/config/default_database/",
    "storage_type":"STORAGE_TYPE",
    "agent_pool_name":"AGENT_POOL_NAME",
    "aws_access_key_id":"AWS_ACCESS_KEY_ID",
    "aws_secret_access_key":"AWS_SECRET_ACCESS_KEY",
    "azure_sas_token":"AZURE_SAS_TOKEN",
    "partition_filter_gcs_path":"FILTER_GCS_PATH"
    }'

Ausführung des Dumper-Tools mit einem cron-Job automatisieren

Sie können inkrementelle Übertragungen automatisieren, indem Sie einen cron-Job verwenden, um das Tool dwh-migration-dumper auszuführen. Automatisieren Sie die Metadatenextraktion, damit für nachfolgende inkrementelle Übertragungen immer ein aktueller Dump aus der Datenquelle verfügbar ist.

Hinweis

Bevor Sie dieses Automatisierungsskript verwenden, müssen Sie Folgendes tun:

1. Erfüllen Sie alle Voraussetzungen für das Dumper-Tool.

2. Installieren Sie die Google Cloud CLI. Das Skript verwendet das gsutil-Befehlszeilentool, um die Dumper-Ausgabe in Cloud Storage hochzuladen.

3. Führen Sie den folgenden Befehl aus, um sich bei Cloud de Confiance zu authentifizieren und gsutil das Hochladen von Dateien in Cloud Storage zu ermöglichen:

   gcloud auth application-default login

Automatisierung planen

1. Speichern Sie das folgende Skript in einer lokalen Datei. Dieses Skript ist so konzipiert, dass es von einem cron-Daemon konfiguriert und ausgeführt wird, um das Extrahieren und Hochladen der Dumper-Ausgabe zu automatisieren.

   #!/bin/bash
   
   # Exit immediately if a command exits with a non-zero status.
   set -e
   # Treat unset variables as an error when substituting.
   set -u
   # Pipelines return the exit status of the last command to exit with a non-zero status.
   set -o pipefail
   
   # These values are used if not overridden by command-line options.
   DUMPER_EXECUTABLE="DUMPER_PATH/dwh-migration-dumper"
   GCS_BASE_PATH="gs://PATH_TO_DUMPER_OUTPUT"
   LOCAL_BASE_DIR="LOCAL_BASE_DIRECTORY_PATH"
   
   # Optional arguments for cloud environments
   DUMPER_HOST=""
   DUMPER_PORT=""
   HIVE_KERBEROS_URL=""
   HIVEQL_RPC_PROTECTION=""
   KERBEROS_AUTHENTICATION="false"
   
   # Function to display usage information
   usage() {
     echo "Usage: $0 [options]"
     echo ""
     echo "Runs the dwh-migration-dumper tool and uploads its output to provided Cloud Storage path."
     echo ""
     echo "Required Options:"
     echo "  --dumper-executable   The full path to the dumper executable."
     echo "  --gcs-base-path       The base Cloud Storage folder to upload dumper output files to. The script generates timestamped ZIP files in this folder."
     echo "  --local-base-dir      The local base directory for logs and temp files."
     echo ""
     echo "Optional Hive connection options:"
     echo "  --host              The hostname for the dumper connection."
     echo "  --port              The port number for the dumper connection."
     echo ""
     echo "To use Kerberos authentication, include the following options."
     echo "If --kerberos-authentication is specified, then --host, --port,"
     echo "--hive-kerberos-url and --hiveql-rpc-protection are all required:"
     echo ""
     echo "  --kerberos-authentication   Enable Kerberos authentication."
     echo "  --hive-kerberos-url    The Hive Kerberos URL."
     echo "  --hiveql-rpc-protection "
     echo "                            The hiveql-rpc-protection level, equal to the value of"
     echo "                            'hadoop.rpc.protection' in '/etc/hadoop/conf/core-site.xml',"
     echo "                            with one of the following values:"
     echo "                            - authentication"
     echo "                            - integrity"
     echo "                            - privacy"
     echo ""
     echo "Other Options:"
     echo "  -h, --help                  Display this help message and exit."
     exit 1
   }
   
   # This loop processes command-line options and overrides the default configuration.
   while [[ "$#" -gt 0 ]]; do
     case $1 in
         --dumper-executable)
             DUMPER_EXECUTABLE="$2"
             shift # past argument
             shift # past value
             ;;
         --gcs-base-path)
             GCS_BASE_PATH="$2"
             shift
             shift
             ;;
         --local-base-dir)
             LOCAL_BASE_DIR="$2"
             shift
             shift
             ;;
         --host)
             DUMPER_HOST="$2"
             shift
             shift
             ;;
         --port)
             DUMPER_PORT="$2"
             shift
             shift
             ;;
         --hive-kerberos-url)
             HIVE_KERBEROS_URL="$2"
             shift
             shift
             ;;
         --hiveql-rpc-protection)
             HIVEQL_RPC_PROTECTION="$2"
             shift
             shift
             ;;
         --kerberos-authentication)
             KERBEROS_AUTHENTICATION="true"
             shift
             ;;
         -h|--help)
             usage
             ;;
         *)
             echo "Unknown option: $1"
             usage
             ;;
     esac
   done
   
   # This runs AFTER parsing arguments to ensure no placeholder values are left.
   if [[ "$DUMPER_EXECUTABLE" == "DUMPER_PATH"* || "$GCS_BASE_PATH" == "gs://PATH_TO_DUMPER_OUTPUT" || "$LOCAL_BASE_DIR" == "LOCAL_BASE_DIRECTORY_PATH" ]]; then
     echo "ERROR: One or more configuration variables have not been set. Please provide them as command-line arguments or edit the script." >&2
     echo "Run with --help for more information." >&2
     exit 1
   fi
   
   # If Kerberos authentication is enabled, check for required fields.
   if [[ "$KERBEROS_AUTHENTICATION" == "true" ]]; then
     if [[ -z "$DUMPER_HOST" || -z "$DUMPER_PORT" || -z "$HIVE_KERBEROS_URL" || -z "$HIVEQL_RPC_PROTECTION" ]]; then
         echo "ERROR: If --kerberos-authentication is enabled, --host, --port, --hive-kerberos-url and --hiveql-rpc-protection must be provided." >&2
         echo "Run with --help for more information." >&2
         exit 1
     fi
   fi
   
   # Remove trailing slashes from GCS_BASE_PATH, if any.
   GCS_BASE_PATH=$(echo "${GCS_BASE_PATH}" | sed 's:/*$::')
   
   # Create unique timestamp and directories for this run
   EPOCH=$(date +%s)
   LOCAL_LOG_DIR="${LOCAL_BASE_DIR}/logs"
   mkdir -p "${LOCAL_LOG_DIR}" # Ensures the base and logs directories exist
   
   # Define the unique log and zip file path for this run
   LOG_FILE="${LOCAL_LOG_DIR}/dumper_execution_${EPOCH}.log"
   ZIP_FILE_NAME="dts-cron-dumper-output_${EPOCH}.zip"
   LOCAL_ZIP_PATH="${LOCAL_BASE_DIR}/${ZIP_FILE_NAME}"
   
   echo "Script execution started. All subsequent output will be logged to: ${LOG_FILE}"
   
   # --- Helper Functions ---
   
   log() { echo "$(date '+%Y-%m-%d %H:%M:%S') - $@" >> "${LOG_FILE}"; }
   
   cleanup() {
     local path_to_remove="$1"
     log "Cleaning up local file/directory: ${path_to_remove}..."
     rm -rf "${path_to_remove}"
   }
   
   # This function is called when the script exits to ensure cleanup and logging happen reliably.
   handle_exit() {
     local exit_code=$?
     # Only run the failure logic if the script is exiting with an error
     if [[ ${exit_code} -ne 0 ]]; then
         log "ERROR: Script is exiting with a failure code (${exit_code})."
         local gcs_log_path_on_failure="${GCS_BASE_PATH}/logs/$(basename "${LOG_FILE}")"
         log "Uploading log file to ${gcs_log_path_on_failure} for debugging..."
         # Attempt to upload the log file on failure, but don't let this command cause the script to exit.
         gsutil cp "${LOG_FILE}" "${gcs_log_path_on_failure}" > /dev/null 2>&1 || log "WARNING: Failed to upload log file to Cloud Storage."
   
     else
         # SUCCESS PATH
         log "Script finished successfully. Now cleaning up local zip file...."
         # Clean up the local zip file ONLY on success
         cleanup "${LOCAL_ZIP_PATH}"
     fi
   
     log "*****Script End*****"
     exit ${exit_code}
   }
   
   # Trap the EXIT signal to run the handle_exit function, ensuring cleanup always happens.
   trap handle_exit EXIT
   
   # Validates the dumper log file based on a strict set of rules.
   validate_dumper_output() {
     local log_file_to_check="$1"
   
     # Check for the specific success message from the dumper tool.
     if grep -q "Dumper execution: SUCCEEDED" "${log_file_to_check}"; then
         log "Validation Successful: Found 'Dumper execution: SUCCEEDED' message."
         return 0 # Success
     else
         log "ERROR: Validation failed. The 'Dumper execution: SUCCEEDED' message was not found."
         return 1 # Failure
     fi
   }
   
   # --- Main Script Logic ---
   
   log "*****Script Start*****"
   log "Dumper Executable: ${DUMPER_EXECUTABLE}"
   log "Cloud Storage Base Path: ${GCS_BASE_PATH}"
   log "Local Base Directory: ${LOCAL_BASE_DIR}"
   
   # Use an array to build the command safely
   dumper_command_args=(
     "--connector" "hiveql"
     "--output" "${LOCAL_ZIP_PATH}"
   )
   
   # Add optional arguments if they are provided
   if [[ -n "${DUMPER_HOST}" ]]; then
   dumper_command_args+=("--host" "${DUMPER_HOST}")
   log "Using Host: ${DUMPER_HOST}"
   fi
   if [[ -n "${DUMPER_PORT}" ]]; then
   dumper_command_args+=("--port" "${DUMPER_PORT}")
   log "Using Port: ${DUMPER_PORT}"
   fi
   if [[ -n "${HIVE_KERBEROS_URL}" ]]; then
   dumper_command_args+=("--hive-kerberos-url" "${HIVE_KERBEROS_URL}")
   log "Using Hive Kerberos URL: ${HIVE_KERBEROS_URL}"
   fi
   if [[ -n "${HIVEQL_RPC_PROTECTION}" ]]; then
   dumper_command_args+=("-Dhiveql.rpc.protection=${HIVEQL_RPC_PROTECTION}")
   log "Using HiveQL RPC Protection: ${HIVEQL_RPC_PROTECTION}"
   fi
   
   log "Starting dumper tool execution..."
   log "COMMAND: JAVA_OPTS=\"-Djavax.security.auth.useSubjectCredsOnly=false\" ${DUMPER_EXECUTABLE} ${dumper_command_args[*]}"
   
   JAVA_OPTS="-Djavax.security.auth.useSubjectCredsOnly=false" "${DUMPER_EXECUTABLE}" "${dumper_command_args[@]}" >> "${LOG_FILE}" 2>&1
   
   log "Dumper process finished."
   
   # Validate the output from the dumper execution for success or failure.
   validate_dumper_output "${LOG_FILE}"
   
   # Upload the ZIP file to Cloud Storage
   gcs_zip_path="${GCS_BASE_PATH}/${ZIP_FILE_NAME}"
   log "Uploading ${LOCAL_ZIP_PATH} to ${gcs_zip_path}..."
   
   if [ ! -f "${LOCAL_ZIP_PATH}" ]; then
     log "ERROR: Expected ZIP file ${LOCAL_ZIP_PATH} not found after dumper execution."
     # The script will exit here with an error code, and the trap will run.
     exit 1
   fi
   
   gsutil cp "${LOCAL_ZIP_PATH}" "${gcs_zip_path}" >> "${LOG_FILE}" 2>&1
   log "Upload to Cloud Storage successful."
   
   # The script will now exit with code 0. The trap will call cleanup and log the script end.

2. Führen Sie den folgenden Befehl aus, um das Script ausführbar zu machen:

   chmod +x PATH_TO_SCRIPT

3. Planen Sie das Skript mit crontab. Ersetzen Sie die Variablen durch die entsprechenden Werte für Ihren Job. Fügen Sie einen Eintrag hinzu, um den Job zu planen. In den folgenden Beispielen wird das Script jeden Tag um 2:30 Uhr ausgeführt:

   Wenn Sie auf einem Host ausgeführt werden, der direkten Zugriff auf den Hive-Metastore hat und keine Kerberos-Authentifizierung erfordert, führen Sie den folgenden Befehl aus:

   # Run the Hive dumper daily at 2:30 AM for incremental BigQuery transfer.
   30 2 * * * PATH_TO_SCRIPT \
     --dumper-executable PATH_TO_DUMPER_EXECUTABLE \
     --gcs-base-path GCS_PATH_TO_UPLOAD_DUMPER_OUTPUT \
     --local-base-dir LOCAL_PATH_TO_SAVE_INTERMEDIARY_FILES

   Wenn für Ihre Hive-Metastore-Instanz eine Kerberos-Authentifizierung erforderlich ist, führen Sie den folgenden Befehl aus:

   # Run the Hive dumper daily at 2:30 AM for incremental BigQuery transfer with Kerberos authentication.
   30 2 * * * PATH_TO_SCRIPT \
     --dumper-executable PATH_TO_DUMPER_EXECUTABLE \
     --gcs-base-path GCS_PATH_TO_UPLOAD_DUMPER_OUTPUT \
     --local-base-dir LOCAL_PATH_TO_SAVE_INTERMEDIARY_FILES \
     --kerberos-authentication \
     --host HIVE_HOST \
     --port HIVE_PORT \
     --hive-kerberos-url HIVE_KERBEROS_URL \
     --hiveql-rpc-protection HIVEQL_RPC_PROTECTION

Überlegungen zur Planung

Um veraltete Daten zu vermeiden, sollten Sie das Dumper-Tool vor der geplanten Datenübertragung ausführen.

Wir empfehlen, das Skript einige Male manuell auszuführen, um die durchschnittliche Zeit zu ermitteln, die das Dumper-Tool zum Generieren der Ausgabe benötigt. Anhand dieser Zeit können Sie einen cron-Jobzeitplan festlegen, der vor dem Übertragungsdurchlauf liegt, um die Datenaktualität zu gewährleisten.

Übertragungsstatus überwachen und ansehen

Sie können Übertragungen auf Ressourcenebene für einzelne Tabellen überwachen, um den Fortschritt zu verfolgen, detaillierte Fehlerinformationen aufzurufen und den Status bestimmter Ressourcen abzufragen, die migriert werden.

Wählen Sie eine der folgenden Optionen aus, um den Fortschritt und Status Ihrer Ressourcen aufzurufen:

  GET https://bigquerydatatransfer.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/transferConfigs/CONFIG_ID/transferResources
  Example Response (abridged) (JSON):
  {
    "transferResources": [
      {
        "name": "projects/.../transferResources/table1",
        "latestStatusDetail": {
          "state": "RESOURCE_TRANSFER_SUCCEEDED",
          "completedPercentage": 100.0
        },
        "updateTime": "2026-02-03T22:42:06Z"
      }
    ]
  }
  

  curl -X GET 

  "https://bigquerydatatransfer.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/transferConfigs/CONFIG_ID/transferResources" 

  -H "Authorization: Bearer $(gcloud auth print-access-token)" 

  -H "Accept: application/json"
  

  GET https://bigquerydatatransfer.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/transferConfigs/CONFIG_ID/transferResources/RESOURCE_ID
  

  curl -X GET 

  "https://bigquerydatatransfer.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/transferConfigs/CONFIG_ID/transferResources/RESOURCE_ID" 

  -H "Authorization: Bearer $(gcloud auth print-access-token)" 

  -H "Accept: application/json"
  

Kontingente und Limits für die gleichzeitige Nutzung

Bei jedem BigQuery Data Transfer Service-Lauf wird mit dem Hive Metastore-Connector ein Storage Transfer Service-Job pro Tabelle ausgeführt.

Sobald das Kontingent erreicht ist, wird die Übertragung angehalten, bis wieder mehr Kontingent verfügbar ist. Storage Transfer Service-Jobs werden im Kundenprojekt erstellt und unterliegen den Kontingenten und Limits für Storage Transfer Service.

Preise

Für die Verwendung des Apache Hive Metastore-Connectors zum Übertragen Ihrer Daten fallen keine Kosten an. Nachdem die Daten übertragen wurden, wird das Speichern der Daten am Zielort in Rechnung gestellt. Hier finden Sie weitere Informationen:

• BigLake
• Dataproc Metastore – Preise
• Cloud Storage – Preise