Creazione tabelle BigLake di archiviazione BLOB
Questo documento descrive come creare un BigLake di archiviazione BLOB di Azure tabella. Una tabella BigLake consente di utilizzare la delega dell'accesso per eseguire query sui dati in Archiviazione BLOB. Accesso delega disaccoppia l'accesso alla tabella BigLake dall'accesso nel datastore sottostante.
Per informazioni sul flusso di dati tra BigQuery e Archiviazione BLOB, consulta Flusso di dati durante l'esecuzione di query sui dati.
Prima di iniziare
Assicurati di avere una connessione per accedere ai dati nello spazio di archiviazione BLOB.
Ruoli obbligatori
Per ottenere le autorizzazioni necessarie per creare una tabella esterna,
chiedi all'amministratore di concederti
Ruolo IAM Amministratore BigQuery (roles/bigquery.admin
) per il tuo set di dati.
Per saperne di più sulla concessione dei ruoli, consulta Gestire l'accesso.
Questo ruolo predefinito contiene le autorizzazioni necessarie per creare una tabella esterna. Per vedere le autorizzazioni esatte obbligatorie, espandi la sezione Autorizzazioni obbligatorie:
Autorizzazioni obbligatorie
Per creare una tabella esterna, sono necessarie le seguenti autorizzazioni:
-
bigquery.tables.create
-
bigquery.connections.delegate
Potresti anche riuscire a ottenere queste autorizzazioni con ruoli personalizzati altri ruoli predefiniti.
Crea un set di dati
Prima di creare una tabella esterna, devi creare un set di dati nella regione supportata. Seleziona una di le seguenti opzioni:Console
Vai alla pagina BigQuery.
- Nel riquadro Explorer, seleziona il progetto in cui vuoi creare del set di dati.
- Espandi Visualizza azioni e fai clic su Crea set di dati.
- Nella pagina Crea set di dati, specifica i seguenti dettagli:
- Per ID set di dati, inserisci un set di dati univoco nome.
- In Località dei dati, scegli una regione supportata.
- (Facoltativo) Per eliminare automaticamente le tabelle, seleziona la casella di controllo Abilita scadenza della tabella e imposta la Durata massima predefinita della tabella in giorni. I dati in Azure non vengono eliminati alla scadenza della tabella.
- Se vuoi utilizzare le collazioni predefinite, Espandi la sezione Opzioni avanzate, quindi seleziona l'opzione Attiva le regole di confronto predefinite.
- Fai clic su Crea set di dati.
SQL
Utilizza l'istruzione DDL CREATE SCHEMA
.
Nell'esempio seguente viene creato un set di dati in
azure-eastus2
regione:
Nella console Google Cloud, vai alla pagina BigQuery.
Nell'editor query, inserisci la seguente istruzione:
CREATE SCHEMA mydataset OPTIONS ( location = 'azure-eastus2');
Fai clic su
Esegui.
Per ulteriori informazioni su come eseguire le query, vedi Eseguire una query interattiva.
bq
In un ambiente a riga di comando, crea un set di dati utilizzando bq mk
comando:
bq --location=LOCATION mk \ --dataset \ PROJECT_ID:DATASET_NAME
Il parametro --project_id
sostituisce il progetto predefinito.
Sostituisci quanto segue:
LOCATION
: la località del set di datiPer informazioni sulle regioni supportate, consulta Località. Dopo creare un set di dati, non puoi modificarne la località. Puoi impostare un valore predefinito per la località utilizzando il valore File
.bigqueryrc
.PROJECT_ID
: il tuo ID progettoDATASET_NAME
: il nome del set di dati che vuoi crearePer creare un set di dati in un progetto diverso da quello predefinito, aggiungi al nome del set di dati nel seguente formato:
PROJECT_ID:DATASET_NAME
.
Creazione di tabelle BigLake su dati non partizionati
Seleziona una delle seguenti opzioni:
Console
Vai alla pagina BigQuery.
Nel riquadro Explorer, espandi il progetto e seleziona un set di dati.
Nella sezione Informazioni sul set di dati, fai clic su
Crea tabella.Nella sezione Origine della pagina Crea tabella, segui questi passaggi:
- Per Crea tabella da, seleziona Archiviazione BLOB di Azure.
In Seleziona percorso di archiviazione BLOB di Azure, inserisci un percorso di archiviazione BLOB di Azure utilizzando il seguente formato:
azure://AZURE_STORAGE_ACCOUNT_NAME.blob.core.windows.net/CONTAINER_NAME/FILE_PATH
Sostituisci quanto segue:
AZURE_STORAGE_ACCOUNT_NAME
: il nome del l'account Archiviazione BLOB. La regione dell'account deve essere la stessa come regione del set di dati.CONTAINER_NAME
: il nome dello spazio di archiviazione BLOB containerizzato.FILE_PATH
: il percorso dei dati che punta a i dati di Archiviazione BLOB. Ad esempio, per un singolo file CSV,FILE_PATH
può esseremyfile.csv
.
Per Formato file, seleziona il formato dei dati in Azure. Formati supportati sono AVRO, CSV, DELTA_LAKE, ICEBERG, JSONL, ORC e PARQUET.
Nella sezione Destinazione, segui questi passaggi:
- In Set di dati, scegli il set di dati appropriato.
- Nel campo Tabella, inserisci il nome della tabella.
- Verifica che l'opzione Tipo di tabella sia impostata su Tabella esterna.
- In ID connessione, scegli l'ID connessione appropriato dalla menu a discesa. Per informazioni sulle connessioni, vedi Connettersi a Archiviazione BLOB.
Nella sezione Schema, puoi abilitare il rilevamento automatico dello schema o specificare manualmente se hai un file di origine. Se non hai un file di origine, devi specificare manualmente uno schema.
Per attivare il rilevamento automatico dello schema, seleziona l'opzione Rilevamento automatico.
Per specificare manualmente uno schema, lascia l'opzione Rilevamento automatico deselezionata. Attiva Modifica come testo e inserisci lo schema della tabella come Array JSON.
Fai clic su Crea tabella.
SQL
Per creare una tabella BigLake, utilizza il metodo
CREATE EXTERNAL TABLE
con la clausola WITH CONNECTION
:
Nella console Google Cloud, vai alla pagina BigQuery.
Nell'editor query, inserisci la seguente istruzione:
CREATE EXTERNAL TABLE DATASET_NAME.TABLE_NAME WITH CONNECTION `AZURE_LOCATION.CONNECTION_NAME` OPTIONS ( format = 'DATA_FORMAT', uris = ['azure://AZURE_STORAGE_ACCOUNT_NAME.blob.core.windows.net/CONTAINER_NAME/FILE_PATH']);
Sostituisci quanto segue:
DATASET_NAME
: il nome del set di dati che creatoTABLE_NAME
: il nome che vuoi assegnare a questo elemento tavolaAZURE_LOCATION
: una località Azure in Google Cloud, ad esempioazure-eastus2
CONNECTION_NAME
: il nome della connessione che creatoDATA_FORMAT
: uno dei formati supportati formati federati di BigQuery, ad esempioAVRO
,CSV
,DELTA_LAKE
oICEBERG
(anteprima)AZURE_STORAGE_ACCOUNT_NAME
: il nome dell'account Archiviazione BLOBCONTAINER_NAME
: il nome del container di archiviazione BLOBFILE_PATH
: il percorso dei dati che punta allo Dati Archiviazione BLOB
Fai clic su
Esegui.
Per ulteriori informazioni su come eseguire le query, vedi Eseguire una query interattiva.
Esempio:
CREATE EXTERNAL TABLE absdataset.abstable WITH CONNECTION `azure-eastus2.abs-read-conn` OPTIONS ( format = 'CSV', uris = ['azure://account_name.blob.core.windows.net/container/path/file.csv']);
bq
Crea un file di definizione della tabella:
bq mkdef \ --source_format=DATA_FORMAT \ --connection_id=AZURE_LOCATION.CONNECTION_NAME \ "azure://AZURE_STORAGE_ACCOUNT_NAME.blob.core.windows.net/CONTAINER_NAME/FILE_PATH" > table_def
Sostituisci quanto segue:
DATA_FORMAT
: uno dei formati supportati formati federati di BigQuery, ad esempioAVRO
,CSV
,ICEBERG
oPARQUET
AZURE_LOCATION
: una località Azure in Google Cloud, comeazure-eastus2
CONNECTION_NAME
: il nome della connessione che hai creatoAZURE_STORAGE_ACCOUNT_NAME
: il nome dell'account Archiviazione BLOBCONTAINER_NAME
: il nome del container di archiviazione BLOBFILE_PATH
: il percorso dei dati che punta ai dati di Archiviazione BLOB
Quindi, crea la tabella BigLake:
bq mk --external_table_definition=table_def DATASET_NAME.TABLE_NAME
Sostituisci quanto segue:
DATASET_NAME
: il nome del set di dati che hai creatoTABLE_NAME
: il nome che vuoi assegnare a questa tabella
Ad esempio, i comandi seguenti creano una nuova tabella BigLake,
my_dataset.my_table
, che può eseguire query sui dati dello spazio di archiviazione BLOB archiviati
nel percorso azure://account_name.blob.core.windows.net/container/path
e
ha una connessione di lettura nella località azure-eastus2
:
bq mkdef \ --source_format=AVRO \ --connection_id=azure-eastus2.read-conn \ "azure://account_name.blob.core.windows.net/container/path" > table_def bq mk \ --external_table_definition=table_def my_dataset.my_table
API
Chiama il metodo tables.insert
API e crea un'istanza
ExternalDataConfiguration
nella risorsa Table
che trasmetti.
Specifica la proprietà schema
o imposta la proprietà
Proprietà autodetect
in true
per attivare il rilevamento automatico dello schema per
e origini dati supportate.
Specifica la proprietà connectionId
per identificare la connessione da utilizzare
per la connessione a Blob Storage.
Crea tabelle BigLake su dati partizionati
Puoi creare una tabella BigLake per i dati partizionati di Hive in Archiviazione BLOB. Dopo aver creato una tabella partizionata esternamente, non puoi cambiare la chiave di partizione. Devi ricreare la tabella per modificare di partizione.
Per creare una tabella BigLake basata su dati partizionati da Hive, seleziona una delle seguenti opzioni:
Console
Vai alla pagina BigQuery.
Nel riquadro Explorer, espandi il progetto e seleziona un set di dati.
Fai clic su
Visualizza azioni, e poi fai clic su Crea tabella. Viene visualizzato il riquadro Crea tabella.Nella sezione Origine, specifica i seguenti dettagli:
Per Crea tabella da, seleziona una delle seguenti opzioni:
- Amazon S3
- Archiviazione BLOB di Azure
Specifica il percorso della cartella utilizzando caratteri jolly. Ad esempio:
- Per Amazon S3:
s3://mybucket/*
- Per l'archiviazione BLOB:
azure://mystorageaccount.blob.core.windows.net/mycontainer/*
La cartella deve trovarsi nella stessa posizione del set di dati che contiene e la tabella che desideri creare, aggiungere o sovrascrivere.
- Per Amazon S3:
Seleziona il tipo di file dall'elenco Formato file.
Seleziona la casella di controllo Partizionamento dei dati di origine e specifica i seguenti dettagli:
- In Seleziona prefisso URI di origine, inserisci il
Prefisso URI. Ad esempio,
s3://mybucket/my_files
. - (Facoltativo) Per richiedere un filtro di partizionamento su tutte le query per questo seleziona la casella di controllo Richiedi filtro di partizione. La richiesta di un filtro di partizionamento può ridurre i costi e migliorare delle prestazioni. Per ulteriori informazioni, vedi Richiedere filtri dei predicati sulle chiavi di partizione nelle query.
Nella sezione Modalità di inferenza della partizione, seleziona una delle le seguenti opzioni:
- Induce automaticamente i tipi: imposta lo schema di partizione
modalità di rilevamento su
AUTO
. - Tutte le colonne sono stringhe: imposta lo schema di partizione
modalità di rilevamento su
STRINGS
. - Fornisci personale: imposta la modalità di rilevamento dello schema di partizione su
CUSTOM
e inserisci manualmente lo schema le informazioni per le chiavi di partizione. Per ulteriori informazioni, vedi Fornisci uno schema della chiave di partizione personalizzato.
- Induce automaticamente i tipi: imposta lo schema di partizione
modalità di rilevamento su
- In Seleziona prefisso URI di origine, inserisci il
Prefisso URI. Ad esempio,
Nella sezione Destinazione, specifica i seguenti dettagli:
- In Progetto, seleziona il progetto in cui vuoi creare nella tabella.
- In Set di dati, seleziona il set di dati in cui creare nella tabella.
- In Tabella, inserisci il nome della tabella che ti interessa. per creare.
- In Tipo di tabella, verifica che sia selezionata l'opzione Tabella esterna.
- In ID connessione, seleziona la connessione che hai creato. in precedenza.
Nella sezione Schema, puoi abilitare il rilevamento automatico dello schema o specificare manualmente se hai un file di origine. Se non hai un file di origine, devi specificare manualmente uno schema.
Per attivare il rilevamento automatico dello schema, seleziona l'opzione Rilevamento automatico.
Per specificare manualmente uno schema, lascia l'opzione Rilevamento automatico deselezionata. Attiva Modifica come testo e inserisci lo schema della tabella come Array JSON.
Per ignorare le righe con valori di colonna aggiuntivi che non corrispondono allo schema, espandi la sezione Opzioni avanzate e seleziona Valori sconosciuti.
Fai clic su Crea tabella.
SQL
Utilizza la
CREATE EXTERNAL TABLE
Istruzione DDL:
Nella console Google Cloud, vai alla pagina BigQuery.
Nell'editor query, inserisci la seguente istruzione:
CREATE EXTERNAL TABLE `PROJECT_ID.DATASET.EXTERNAL_TABLE_NAME` WITH PARTITION COLUMNS ( PARTITION_COLUMN PARTITION_COLUMN_TYPE, ) WITH CONNECTION `PROJECT_ID.REGION.CONNECTION_ID` OPTIONS ( hive_partition_uri_prefix = "HIVE_PARTITION_URI_PREFIX", uris=['FILE_PATH'], format ="TABLE_FORMAT" );
Sostituisci quanto segue:
PROJECT_ID
: il nome del tuo progetto in cui vuoi creare la tabella, ad esempiomyproject
DATASET
: il nome del Set di dati BigQuery in cui vuoi creare la tabella ad esempio,mydataset
EXTERNAL_TABLE_NAME
: il nome della tabella che vuoi creare, ad esempiomytable
PARTITION_COLUMN
: il nome del colonna di partizionamentoPARTITION_COLUMN_TYPE
: il tipo di colonna di partizionamentoREGION
: la regione che contiene connessione, ad esempious
CONNECTION_ID
: il nome della connessione per esempio,myconnection
HIVE_PARTITION_URI_PREFIX
: partizionamento hive URI, ad esempio:s3://mybucket/
azure://mystorageaccount.blob.core.windows.net/mycontainer/
FILE_PATH
: percorso dell'origine dati per il tabella esterna che vuoi creare, ad esempio:s3://mybucket/*.parquet
azure://mystorageaccount.blob.core.windows.net/mycontainer/*.parquet
TABLE_FORMAT
: il formato della tabella che che vuoi creare, ad esempioPARQUET
Fai clic su
Esegui.
Per ulteriori informazioni su come eseguire le query, vedi Eseguire una query interattiva.
Esempi
L'esempio seguente crea una tabella BigLake sopra partizionati in Amazon S3. Lo schema viene rilevato automaticamente.
CREATE EXTERNAL TABLE `my_dataset.my_table` WITH PARTITION COLUMNS ( sku STRING, ) WITH CONNECTION `us.my-connection` OPTIONS( hive_partition_uri_prefix = "s3://mybucket/products", uris = ['s3://mybucket/products/*'] );
L'esempio seguente crea una tabella BigLake sopra di dati partizionati nello spazio di archiviazione BLOB. Lo schema è specificato.
CREATE EXTERNAL TABLE `my_dataset.my_table` ( ProductId INTEGER, ProductName, STRING, ProductType, STRING ) WITH PARTITION COLUMNS ( sku STRING, ) WITH CONNECTION `us.my-connection` OPTIONS( hive_partition_uri_prefix = "azure://mystorageaccount.blob.core.windows.net/mycontainer/products", uris = ['azure://mystorageaccount.blob.core.windows.net/mycontainer/*'] );
bq
Per prima cosa, utilizza
Comando bq mkdef
per
crea un file di definizione della tabella:
bq mkdef \ --source_format=SOURCE_FORMAT \ --connection_id=REGION.CONNECTION_ID \ --hive_partitioning_mode=PARTITIONING_MODE \ --hive_partitioning_source_uri_prefix=URI_SHARED_PREFIX \ --require_hive_partition_filter=BOOLEAN \ URIS > DEFINITION_FILE
Sostituisci quanto segue:
SOURCE_FORMAT
: il formato dei dati esterni sorgente. Ad esempio,CSV
.REGION
: la regione che contiene connessione attiva, ad esempious
.CONNECTION_ID
: il nome della connessione per ad esempiomyconnection
.PARTITIONING_MODE
: la modalità di partizionamento di Hive. Utilizza uno dei seguenti i seguenti valori:AUTO
: rileva automaticamente i nomi e i tipi di chiavi.STRINGS
: converti automaticamente i nomi delle chiavi in stringhe.CUSTOM
: codifica lo schema della chiave nel prefisso dell'URI di origine.
URI_SHARED_PREFIX
: il prefisso dell'URI di origine.BOOLEAN
: specifica se richiedere un filtro per i predicati nella query nel tempo. Questo flag è facoltativo. Il valore predefinito èfalse
.URIS
: il percorso di Amazon S3 o Cartella di archiviazione BLOB, utilizzando carattere jolly.DEFINITION_FILE
: il percorso file di definizione della tabella sul tuo in una macchina virtuale.
Se PARTITIONING_MODE
è CUSTOM
, includi lo schema della chiave di partizione
nel prefisso dell'URI di origine, utilizzando il seguente formato:
--hive_partitioning_source_uri_prefix=GCS_URI_SHARED_PREFIX/{KEY1:TYPE1}/{KEY2:TYPE2}/...
Dopo aver creato il file di definizione della tabella, utilizza il metodo
Comando bq mk
per
crea la tabella BigLake:
bq mk --external_table_definition=DEFINITION_FILE \ DATASET_NAME.TABLE_NAME \ SCHEMA
Sostituisci quanto segue:
DEFINITION_FILE
: il percorso del file di definizione della tabella.DATASET_NAME
: il nome del set di dati che contiene tabella.TABLE_NAME
: il nome della tabella che stai creando.SCHEMA
: specifica un percorso a un File di schema JSON, o specifica lo schema nella formafield:data_type,field:data_type,...
. Per utilizzare lo schema rilevamento automatico, ometti questo argomento.
Esempi
L'esempio seguente utilizza la modalità di partizionamento Hive AUTO
per Amazon S3
dati:
bq mkdef --source_format=CSV \
--connection_id=us.my-connection \
--hive_partitioning_mode=AUTO \
--hive_partitioning_source_uri_prefix=s3://mybucket/myTable \
--metadata_cache_mode=AUTOMATIC \
s3://mybucket/* > mytable_def
bq mk --external_table_definition=mytable_def \
mydataset.mytable \
Region:STRING,Quarter:STRING,Total_sales:INTEGER
L'esempio seguente utilizza la modalità di partizionamento Hive STRING
per Amazon S3
dati:
bq mkdef --source_format=CSV \
--connection_id=us.my-connection \
--hive_partitioning_mode=STRING \
--hive_partitioning_source_uri_prefix=s3://mybucket/myTable \
s3://mybucket/myTable/* > mytable_def
bq mk --external_table_definition=mytable_def \
mydataset.mytable \
Region:STRING,Quarter:STRING,Total_sales:INTEGER
L'esempio seguente utilizza la modalità di partizionamento Hive CUSTOM
per
Dati di Archiviazione BLOB:
bq mkdef --source_format=CSV \
--connection_id=us.my-connection \
--hive_partitioning_mode=CUSTOM \
--hive_partitioning_source_uri_prefix=azure://mystorageaccount.blob.core.windows.net/mycontainer/{dt:DATE}/{val:STRING} \
azure://mystorageaccount.blob.core.windows.net/mycontainer/* > mytable_def
bq mk --external_table_definition=mytable_def \
mydataset.mytable \
Region:STRING,Quarter:STRING,Total_sales:INTEGER
API
Per impostare il partizionamento Hive utilizzando l'API BigQuery, includi il comando
hivePartitioningOptions
in ExternalDataConfiguration
quando crei il file di definizione della tabella.
Per creare una tabella BigLake, devi anche specificare un valore
per il campo connectionId
.
Se imposti il campo hivePartitioningOptions.mode
su CUSTOM
, devi
codificare lo schema della chiave di partizione
hivePartitioningOptions.sourceUriPrefix
come segue:
s3://BUCKET/PATH_TO_TABLE/{KEY1:TYPE1}/{KEY2:TYPE2}/...
Per applicare l'utilizzo di un filtro per i predicati in fase di query, imposta il valore
hivePartitioningOptions.requirePartitionFilter
su true
.
Tabelle Delta Lake
Per richiedere assistenza o feedback per questa funzione, invia un'email a bq-federated-formats@google.com.
Delta Lake è un formato di tabella open source che supporta dati su scala petabyte tabelle. È possibile eseguire query sulle tabelle Delta Lake come tabelle temporanee e permanenti, ed è supportato come BigLake dalla tabella.
Sincronizzazione schema
Delta Lake mantiene uno schema canonico nei propri metadati. Tu non può aggiornare uno schema utilizzando un file di metadati JSON. Per aggiornare lo schema:
Usa il comando
bq update
con il flag--autodetect_schema
:bq update --autodetect_schema PROJECT_ID:DATASET.TABLE
Sostituisci quanto segue:
PROJECT_ID
: l'ID progetto contenente la tabella che voglio aggiornareDATASET
: il set di dati contenente la tabella che voglio aggiornareTABLE
: la tabella che vuoi aggiornare
Conversione del tipo
BigQuery converte i tipi di dati di Delta Lake nel seguente Tipi di dati BigQuery:
Tipo di lago delta | Tipo di BigQuery |
---|---|
boolean |
BOOL |
byte |
INT64 |
int |
INT64 |
long |
INT64 |
float |
FLOAT64 |
double |
FLOAT64 |
Decimal(P/S) |
NUMERIC o BIG_NUMERIC in base alla precisione |
date |
DATE |
time |
TIME |
timestamp (not partition column) |
TIMESTAMP |
timestamp (partition column) |
DATETIME |
string |
STRING |
binary |
BYTES |
array<Type> |
ARRAY<Type> |
struct |
STRUCT |
map<KeyType, ValueType> |
ARRAY<Struct<key KeyType, value ValueType>> |
Limitazioni
Alle tabelle Delta Lake si applicano le seguenti limitazioni:
Si applicano limitazioni per le tabelle esterne alle tabelle Delta Lake.
Le tabelle Delta Lake sono supportate solo BigQuery Omni e dispongono della funzionalità limitazioni.
Non puoi aggiornare una tabella con un nuovo file di metadati JSON. Devi utilizzare un'impostazione Rileva l'operazione di aggiornamento della tabella dello schema. Vedi Schema Google Cloud per ulteriori informazioni.
Le funzionalità di sicurezza di BigLake proteggono solo Delta Lake quando si accede tramite i servizi BigQuery.
Crea una tabella Delta Lake
L'esempio seguente crea una tabella esterna utilizzando CREATE EXTERNAL
TABLE
con l'istruzione
Formato Delta Lake:
CREATE [OR REPLACE] EXTERNAL TABLE table_name WITH CONNECTION connection_name OPTIONS ( format = 'DELTA_LAKE', uris = ["parent_directory"] );
Sostituisci quanto segue:
table_name: il nome della tabella.
connection_name: il nome della connessione. La connessione deve identificare uno Amazon S3 o un Origine Archiviazione BLOB.
parent_directory: l'URI della directory principale.
Trasferimento cross-cloud con Delta Lake
L'esempio seguente utilizza la classe LOAD DATA
per caricare i dati nella tabella appropriata:
LOAD DATA [INTO | OVERWRITE] table_name FROM FILES ( format = 'DELTA_LAKE', uris = ["parent_directory"] ) WITH CONNECTION connection_name;
Per altri esempi di trasferimenti di dati tra cloud, consulta Caricare dati con trasferimenti di dati tra cloud operazioni.
Esegui query su tabelle BigLake
Per ulteriori informazioni, vedi Dati di archiviazione BLOB di query.
Visualizza i metadati delle risorse con INFORMATION_SCHEMA
Puoi visualizzare i metadati delle risorse con le visualizzazioni INFORMATION_SCHEMA
. Quando esegui una query
JOBS_BY_*
,
JOBS_TIMELINE_BY_*
e
RESERVATION*
viste, devi specificare il percorso di elaborazione della query
che si trova nella regione della tabella. Per informazioni su BigQuery Omni
tutte le località, consulta la sezione Località. Per tutti
in altre tabelle di sistema, la specifica della località del job di query è facoltativo.
Per informazioni sulle tabelle di sistema supportate da BigQuery Omni, vedi Limitazioni.
Per eseguire query sulle tabelle di sistema JOBS_*
e RESERVATION*
, seleziona una delle seguenti opzioni
per specificare la località di elaborazione:
Console
Vai alla pagina BigQuery.
Se la scheda Editor non è visibile, fai clic su
Crea nuova query.Fai clic su Altro > Impostazioni query. La sezione Impostazioni query si apre la finestra di dialogo.
Nella finestra di dialogo Impostazioni query, per Impostazioni aggiuntive >. Località dei dati, seleziona la regione BigQuery che si trova nella regione di BigQuery Omni. Ad esempio, se la tua regione di BigQuery Omni è
aws-us-east-1
, specificareus-east4
.Seleziona i campi rimanenti e fai clic su Salva.
bq
Utilizza il flag --location
per impostare la località di elaborazione del job su
regione BigQuery, ossia
collocata nella regione di BigQuery Omni.
Ad esempio, se la tua regione di BigQuery Omni è aws-us-east-1
,
specificare us-east4
.
Esempio
bq query --use_legacy_sql=false --location=us-east4 \
"SELECT * FROM region-azure-eastus2.INFORMATION_SCHEMA.JOBS limit 10;"
API
Se esegui i job in modo programmatico,
Imposta l'argomento location sulla regione BigQuery
che si trova nella regione di BigQuery Omni.
Ad esempio, se la tua regione di BigQuery Omni è aws-us-east-1
,
specificare us-east4
.
Controlli di servizio VPC
Puoi utilizzare i perimetri Controlli di servizio VPC per limitare l'accesso BigQuery Omni a un servizio cloud esterno come livello aggiuntivo della difesa. Ad esempio, i perimetri Controlli di servizio VPC possono limitare le esportazioni dalle tue tabelle BigQuery Omni a uno specifico bucket Amazon S3 o BLOB Storage.
Per saperne di più sui Controlli di servizio VPC, consulta Panoramica dei Controlli di servizio VPC.
Autorizzazione obbligatoria
Assicurati di disporre delle autorizzazioni necessarie per configurare i perimetri di servizio. Per visualizzare un elenco dei ruoli IAM richiesti per configurare i Controlli di servizio VPC; consulta l'articolo Controllo dell'accesso con IAM nel documentazione sui Controlli di servizio VPC.
Configurare Controlli di servizio VPC utilizzando la console Google Cloud
Nel menu di navigazione della console Google Cloud, fai clic su Sicurezza e poi fai clic su Controlli di servizio VPC.
Per configurare Controlli di servizio VPC per BigQuery Omni, segui i passaggi nella sezione Creare un servizio perimetro guida. Nel riquadro Regole in uscita, segui questi passaggi:
Nel riquadro Regole in uscita, fai clic su Aggiungi regola.
Nella sezione Da attributi del client API, seleziona un'opzione dall'elenco Identity.
Seleziona Attributi A delle risorse esterne.
Per aggiungere una risorsa esterna, fai clic su Aggiungi risorse esterne.
Nella finestra di dialogo Aggiungi risorsa esterna, per Nome risorsa esterna, inserisci un nome risorsa valido. Ad esempio:
Per Amazon Simple Storage Service (Amazon S3):
s3://BUCKET_NAME
Sostituisci BUCKET_NAME con il nome del tuo bucket Amazon S3.
Per l'archiviazione BLOB di Azure:
azure://myaccount.blob.core.windows.net/CONTAINER_NAME
Sostituisci CONTAINER NAME con il nome del tuo spazio di archiviazione BLOB containerizzato.
Per un elenco degli attributi delle regole in uscita, consulta Riferimento per le regole in uscita.
Seleziona i metodi che vuoi consentire sulle risorse esterne:
- Se vuoi consentire tutti i metodi, seleziona Tutti i metodi nella Metodi.
- Se vuoi consentire metodi specifici, seleziona Metodo selezionato, fai clic su Seleziona metodi e poi seleziona i metodi che consentire l'accesso alle risorse esterne.
Fai clic su Crea perimetro.
Configura i Controlli di servizio VPC utilizzando gcloud CLI
Per configurare i Controlli di servizio VPC utilizzando gcloud CLI, segui questi passaggi passaggi:
- Imposta il criterio di accesso predefinito.
- Crea il file di input del criterio in uscita.
- Aggiungi il criterio in uscita.
Imposta il criterio di accesso predefinito
Un criterio di accesso è un container a livello di organizzazione per i livelli di accesso e i perimetri di servizio. Per informazioni sull'impostazione di criterio di accesso predefinito o su come ottenere il nome di un criterio di accesso, consulta Gestione di un criterio di accesso .
Crea il file di input del criterio in uscita
Un blocco di regole in uscita definisce l'accesso consentito alle risorse dall'interno di un perimetro
fuori da questo perimetro. Per le risorse esterne, la proprietà externalResources
definisce i percorsi delle risorse esterne a cui è consentito l'accesso dall'interno
Perimetro Controlli di servizio VPC.
Le regole in uscita possono essere configurate utilizzando
un file JSON o un file YAML. Nell'esempio seguente viene utilizzato il formato .yaml
:
- egressTo: operations: - serviceName: bigquery.googleapis.com methodSelectors: - method: "*" *OR* - permission: "externalResource.read" externalResources: - EXTERNAL_RESOURCE_PATH egressFrom: identityType: IDENTITY_TYPE *OR* identities: - serviceAccount:SERVICE_ACCOUNT
egressTo
: elenca le operazioni di servizio consentite sulle risorse Google Cloud in progetti specifici al di fuori del perimetro.operations
: elenca servizi e azioni o metodi accessibili che un un client che soddisfa le condizioni di bloccofrom
è autorizzato ad accedere.serviceName
: impostabigquery.googleapis.com
per BigQuery Omni.methodSelectors
: elenca i metodi che un client soddisfa le condizionifrom
a cui possono accedere. Per informazioni su metodi e autorizzazioni limitati per i servizi, vedi Limitazioni dei metodi di servizio supportati.method
: un metodo di servizio valido oppure\"*\"
per consentire tutti i metodiserviceName
.permission
: un'autorizzazione di servizio valida, come\"*\"
,externalResource.read
oexternalResource.write
. Accesso alle risorse all'esterno del perimetro è consentita per le operazioni che richiedono questa autorizzazione.externalResources
: elenca le risorse esterne ai client all'interno di un perimetro a cui possono accedere. Sostituisci EXTERNAL_RESOURCE_PATH con un valore valido bucket Amazon S3, ad esempios3://bucket_name
, oppure un Percorso del container di archiviazione BLOB, ad esempioazure://myaccount.blob.core.windows.net/container_name
.egressFrom
: elenca le operazioni di servizio consentite su Google Cloud in progetti specificati all'interno del perimetro.identityType
oidentities
: definisce i tipi di identità che possono accedere all'elemento al di fuori del perimetro. Sostituisci IDENTITY_TYPE con uno dei seguenti valori validi:ANY_IDENTITY
: per consentire tutte le identità.ANY_USER_ACCOUNT
: per autorizzare tutti gli utenti.ANY_SERVICE_ACCOUNT
: per consentire tutti gli account di servizio
identities
: elenca gli account di servizio che possono accedere alle risorse specificate fuori dal perimetro.(Facoltativo)
serviceAccount
: sostituisci SERVICE_ACCOUNT con il account di servizio in grado di accedere alle risorse specificate all'esterno perimetrale.
Esempi
L'esempio seguente è un criterio che consente le operazioni in uscita dall'interno
il perimetro alla località Amazon S3 s3://mybucket
in AWS.
- egressTo: operations: - serviceName: bigquery.googleapis.com methodSelectors: - method: "*" externalResources: - s3://mybucket - s3://mybucket2 egressFrom: identityType: ANY_IDENTITY
L'esempio seguente consente le operazioni in uscita verso un container di archiviazione BLOB:
- egressTo: operations: - serviceName: bigquery.googleapis.com methodSelectors: - method: "*" externalResources: - azure://myaccount.blob.core.windows.net/mycontainer egressFrom: identityType: ANY_IDENTITY
Per ulteriori informazioni sui criteri di traffico in uscita, consulta Riferimento alle regole in uscita.
Aggiungi il criterio in uscita
Per aggiungere il criterio in uscita quando crei un nuovo perimetro di servizio, utilizza il metodo
Comando gcloud access-context-manager perimeters create
.
Ad esempio, il seguente comando crea una nuova
perimetro denominato omniPerimeter
che include il progetto con numero di progetto
12345
, limita l'API BigQuery e aggiunge un criterio in uscita
definita nel file egress.yaml
:
gcloud access-context-manager perimeters create omniPerimeter \ --title="Omni Perimeter" \ --resources=projects/12345 \ --restricted-services=bigquery.googleapis.com \ --egress-policies=egress.yaml
Per aggiungere il criterio in uscita a un perimetro di servizio esistente, utilizza il metodo
Comando gcloud access-context-manager perimeters update
.
Ad esempio, il comando seguente aggiunge un criterio in uscita definito nel
egress.yaml
a un perimetro di servizio esistente denominato omniPerimeter
:
gcloud access-context-manager perimeters update omniPerimeter --set-egress-policies=egress.yaml
Verifica il perimetro
Per verificare il perimetro, utilizza il metodo
Comando gcloud access-context-manager perimeters describe
:
gcloud access-context-manager perimeters describe PERIMETER_NAME
Sostituisci PERIMETER_NAME con il nome del perimetro.
Ad esempio, il seguente comando descrive il perimetro omniPerimeter
:
gcloud access-context-manager perimeters describe omniPerimeter
Per ulteriori informazioni, vedi Gestione dei perimetri di servizio
Consenti a BigQuery Omni di accedere all'archiviazione BLOB
Per richiedere assistenza o feedback per questa funzione, invia un'email a bq-omni-customer-support@google.com.
In qualità di amministratore BigQuery, puoi creare una regola di rete per concedere a BigQuery Omni l'accesso alle tue risorse di archiviazione BLOB. Ciò garantisce che solo i VPC BigQuery Omni autorizzati possano interagire l'archiviazione BLOB, per migliorare la sicurezza dei dati.
Applica una regola di rete per il VPC di BigQuery Omni
Per applicare una regola di rete, utilizza Azure PowerShell o Terraform:
Azure PowerShell
Esegui questo comando per aggiungere una regola di rete al tuo account di archiviazione che
specifica gli ID subnet BigQuery Omni recuperati come
VirtualNetworkResourceId
.
Add-AzStorageAccountNetworkRule` -ResourceGroupName "RESOURCE_GROUP_NAME"` -Name "STORAGE_ACCOUNT_NAME"` -VirtualNetworkResourceId "SUBNET_ID1","SUBNET_ID2"
Sostituisci quanto segue:
RESOURCE_GROUP_NAME
: nome del gruppo di risorse.STORAGE_ACCOUNT_NAME
: il nome dell'account di archiviazione.SUBNET_ID1
,SUBNET_ID1
: gli ID subnet. Puoi trovare queste informazioni nella tabella in questa pagina.
Terraform
Aggiungi quanto segue al file di configurazione Terraform:
resource "azurerm_storage_account_network_rules" "example" { storage_account_name = "STORAGE_ACCOUNT_NAME" resource_group_name = "RESOURCE_GROUP_NAME" default_action = "Allow" bypass = ["Logging", "Metrics", "AzureServices"] virtual_network_subnet_ids = ["SUBNET_ID1","SUBNET_ID2"] }
Sostituisci quanto segue:
STORAGE_ACCOUNT_NAME
: il nome dell'account di archiviazione.RESOURCE_GROUP_NAME
: nome del gruppo di risorse.SUBNET_ID1
,SUBNET_ID1
: gli ID subnet. Puoi trovare queste informazioni nella tabella in questa pagina.
ID risorsa VPC di BigQuery Omni
Regione | ID subnet |
---|---|
azzurro-eastus2 |
/subscriptions/95f30708-58d1-48ba-beac-d71870c3b2f5/resourceGroups/bqe-prod-eastus2-resource-group/providers/Microsoft.Network/virtualNetworks/bqe-prod-eastus2-network/subnets/azure-prod-eastus21-yurduaaaaa-private /subscriptions/95f30708-58d1-48ba-beac-d71870c3b2f5/resourceGroups/bqe-prod-eastus2-resource-group/providers/Microsoft.Network/virtualNetworks/bqe-prod-eastus2-network/subnets/azure-prod-eastus22-yurduaaaab-private |
Limitazioni
Per un elenco completo delle limitazioni che si applicano alle tabelle BigLake basate su Amazon S3 e Blob Storage, consulta le limitazioni.
Passaggi successivi
- Scopri di più su BigQuery Omni.
- Scopri di più sulle tabelle BigLake.
- Scopri come esportare i risultati delle query in Archiviazione BLOB.