Questa pagina è stata tradotta dall'API Cloud Translation.

Crea una tabella esterna di Bigtable

Questa pagina descrive come creare una tabella esterna permanente di BigQuery che possono essere utilizzati per eseguire query sui dati archiviati in Bigtable. L'esecuzione di query sui dati in Bigtable è disponibile in tutti i prodotti Bigtable di località.

Prima di iniziare

Prima di creare una tabella esterna, raccogli alcune informazioni e assicurati di disponi dell'autorizzazione per creare la tabella.

Ruoli obbligatori

Per creare una tabella esterna da utilizzare per eseguire query sui dati Bigtable, devi essere un'entità in Bigtable Admin (roles/bigtable.admin) per l'istanza contenente la tabella di origine.

Hai anche bisogno di bigquery.tables.create BigQuery Autorizzazione IAM (Identity and Access Management).

Ciascuno dei seguenti ruoli predefiniti di Identity and Access Management include questa autorizzazione:

Editor dati BigQuery (roles/bigquery.dataEditor)
Proprietario dati BigQuery (roles/bigquery.dataOwner)
Amministratore BigQuery (roles/bigquery.admin)

Se non sei un'entità in uno di questi ruoli, chiedi all'amministratore per concederti l'accesso o per creare la tabella esterna per te.

Per ulteriori informazioni su ruoli e autorizzazioni di Identity and Access Management in BigQuery, vedi Ruoli e ruoli predefiniti autorizzazioni. Per visualizzare le informazioni su Autorizzazioni Bigtable, consulta Controllo dell'accesso con Identity and Access Management.

crea o identifica un set di dati

Prima di creare una tabella esterna, devi crea un set di dati che contenga la tabella esterna. Tu puoi anche usare un set di dati esistente.

(Facoltativo) Designa o crea un cluster

Se prevedi di eseguire query frequentemente sugli stessi dati utilizzati per la tua produzione consigliamo di designare un cluster in un'applicazione Istanza Bigtable da utilizzare esclusivamente per BigQuery e analisi. Questo isola il traffico dal cluster o dai cluster che utilizzi per le operazioni di lettura e scrittura della tua applicazione. Per scoprire di più sulla replica sulla creazione di istanze con più di un cluster, consulta Informazioni di replica.

Identifica o crea un profilo dell'app

Prima di creare una tabella esterna, decidi quale app Bigtable profilo che BigQuery deve utilizzare per leggere i dati. I nostri suggerimenti di utilizzare un profilo dell'app che definisci per l'uso esclusivo con in BigQuery.

Se nell'istanza Bigtable è presente un cluster dedicato per accedere a BigQuery, configura il profilo dell'app da utilizzare il routing a cluster singolo al cluster in questione.

Scoprire come funzionano i profili dell'app Bigtable al lavoro, consulta Informazioni sui profili delle app. Per scoprire come creare un nuovo profilo dell'app; consulta l'articolo Creare e configurare l'app profili.

Recupera l'URI Bigtable

Per creare una tabella esterna per un'origine dati Bigtable, devi per fornire l'URI Bigtable. per recuperare i dati Bigtable URI, segui questi passaggi:

Apri la pagina Bigtable nella console.

Vai a Bigtable
Recupera i seguenti dettagli su Bigtable origine dati:
- Il tuo ID progetto
- ID istanza Bigtable
- L'ID del profilo dell'app Bigtable che prevedi di utilizzare
- Il nome della tabella Bigtable
Scrivi l'URI di Bigtable utilizzando il seguente formato, dove:
- project_id è il progetto che contiene Istanza Bigtable
- instance_id è l'ID dell'istanza Bigtable
- (Facoltativo) app_profile è l'ID profilo dell'app che vuoi utilizzare
- table_name è il nome della tabella su cui stai eseguendo la query
https://googleapis.com/bigtable/projects/project_id/instances/instance_id[/appProfiles/app_profile]/tables/table_name

Crea tabelle esterne permanenti

Quando crei una tabella esterna permanente in BigQuery che collegate a un'origine dati Bigtable, esistono due opzioni per che specifica il formato della tabella esterna:

Se utilizzi l'API o lo strumento a riga di comando bq, crei un'istanza file di definizione della tabella che definisce lo schema e i metadati per la tabella esterna.
Se utilizzi SQL, usa l'opzione uri di CREATE EXTERNAL TABLE per specificare la tabella Bigtable da cui eseguire il pull dei dati, l'opzione bigtable_options per specificare lo schema della tabella.

I dati della tabella esterna non vengono archiviati nella tabella BigQuery. Poiché la tabella è permanente, puoi utilizzare l'accesso a livello di set di dati per condividere la tabella con altri utenti che hanno accesso all'origine dati Bigtable sottostante.

Per creare una tabella permanente, scegli uno dei seguenti metodi.

SQL

Puoi creare una tabella esterna permanente eseguendo il comando CREATE EXTERNAL TABLE Istruzione DDL. Devi specificare lo schema della tabella in modo esplicito come parte dell'istruzione le opzioni di CPU e memoria disponibili.

Nella console Google Cloud, vai alla pagina BigQuery.

Vai a BigQuery
Nell'editor query, inserisci la seguente istruzione:
```
CREATE EXTERNAL TABLE DATASET.NEW_TABLE
OPTIONS (
  format = 'CLOUD_BIGTABLE',
  uris = ['URI'],
  bigtable_options = BIGTABLE_OPTIONS );
```
Sostituisci quanto segue:
- DATASET: il set di dati in cui creare Tabella esterna di Bigtable.
- NEW_TABLE: il nome del Tabella esterna di Bigtable.
- URI: l'URI di Bigtable che vuoi utilizzare come origine dati. Questo URI deve seguire il formato descritto in Recupero dell'URI Bigtable.
- BIGTABLE_OPTIONS: lo schema per Tabella Bigtable in formato JSON. Per un elenco di Opzioni di definizione delle tabelle Bigtable, consulta BigtableOptions nel riferimento dell'API REST.
Fai clic su Esegui.

Per ulteriori informazioni su come eseguire le query, vedi Eseguire una query interattiva.

Un'istruzione per creare una tabella Bigtable esterna potrebbe avere il seguente aspetto:

CREATE EXTERNAL TABLE mydataset.BigtableTable
OPTIONS (
  format = 'CLOUD_BIGTABLE',
  uris = ['https://googleapis.com/bigtable/projects/myproject/instances/myBigtableInstance/tables/table1'],
  bigtable_options =
    """
    {
      columnFamilies: [
        {
          "familyId": "familyId1",
          "type": "INTEGER",
          "encoding": "BINARY"
        }
      ],
      readRowkeyAsString: true
    }
    """
);

bq

Puoi creare una tabella nello strumento a riga di comando bq utilizzando Comando bq mk. Quando utilizzerai lo strumento a riga di comando bq per creare una tabella collegata a un'origine dati esterna, identifichi lo schema della tabella utilizzando file di definizione della tabella.

Utilizza il comando bq mk per creare una tabella permanente.
```
bq mk \
--external_table_definition=DEFINITION_FILE \
DATASET.TABLE
```
Sostituisci quanto segue:
- DEFINITION_FILE: il percorso file di definizione della tabella sul tuo computer locale.
- DATASET: il nome del set di dati che contiene la tabella.
- TABLE: il nome della tabella che stai creando.

API

Utilizza la tables.insert API e crea un'istanza ExternalDataConfiguration nella risorsa Table che trasmetti.

Per la proprietà sourceUris nella risorsa Table, specificare un solo URI Bigtable. Deve essere un URL HTTPS valido.

Per la proprietà sourceFormat, specifica "BIGTABLE".

Java

Prima di provare questo esempio, segui le istruzioni per la configurazione di Java nel Guida rapida di BigQuery con librerie client. Per ulteriori informazioni, consulta API Java BigQuery documentazione di riferimento.

Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per le librerie client.

import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.BigtableColumn;
import com.google.cloud.bigquery.BigtableColumnFamily;
import com.google.cloud.bigquery.BigtableOptions;
import com.google.cloud.bigquery.ExternalTableDefinition;
import com.google.cloud.bigquery.QueryJobConfiguration;
import com.google.cloud.bigquery.TableId;
import com.google.cloud.bigquery.TableInfo;
import com.google.cloud.bigquery.TableResult;
import com.google.common.collect.ImmutableList;
import org.apache.commons.codec.binary.Base64;

// Sample to queries an external bigtable data source using a permanent table
public class QueryExternalBigtablePerm {

  public static void main(String[] args) {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "MY_PROJECT_ID";
    String bigtableInstanceId = "MY_INSTANCE_ID";
    String bigtableTableName = "MY_BIGTABLE_NAME";
    String bigqueryDatasetName = "MY_DATASET_NAME";
    String bigqueryTableName = "MY_TABLE_NAME";
    String sourceUri =
        String.format(
            "https://googleapis.com/bigtable/projects/%s/instances/%s/tables/%s",
            projectId, bigtableInstanceId, bigtableTableName);
    String query = String.format("SELECT * FROM %s ", bigqueryTableName);
    queryExternalBigtablePerm(bigqueryDatasetName, bigqueryTableName, sourceUri, query);
  }

  public static void queryExternalBigtablePerm(
      String datasetName, String tableName, String sourceUri, String query) {
    try {
      // Initialize client that will be used to send requests. This client only needs to be created
      // once, and can be reused for multiple requests.
      BigQuery bigquery = BigQueryOptions.getDefaultInstance().getService();

      BigtableColumnFamily.Builder statsSummary = BigtableColumnFamily.newBuilder();

      // Configuring Columns
      BigtableColumn connectedCell =
          BigtableColumn.newBuilder()
              .setQualifierEncoded(Base64.encodeBase64String("connected_cell".getBytes()))
              .setFieldName("connected_cell")
              .setType("STRING")
              .setEncoding("TEXT")
              .build();
      BigtableColumn connectedWifi =
          BigtableColumn.newBuilder()
              .setQualifierEncoded(Base64.encodeBase64String("connected_wifi".getBytes()))
              .setFieldName("connected_wifi")
              .setType("STRING")
              .setEncoding("TEXT")
              .build();
      BigtableColumn osBuild =
          BigtableColumn.newBuilder()
              .setQualifierEncoded(Base64.encodeBase64String("os_build".getBytes()))
              .setFieldName("os_build")
              .setType("STRING")
              .setEncoding("TEXT")
              .build();

      // Configuring column family and columns
      statsSummary
          .setColumns(ImmutableList.of(connectedCell, connectedWifi, osBuild))
          .setFamilyID("stats_summary")
          .setOnlyReadLatest(true)
          .setEncoding("TEXT")
          .setType("STRING")
          .build();

      // Configuring BigtableOptions is optional.
      BigtableOptions options =
          BigtableOptions.newBuilder()
              .setIgnoreUnspecifiedColumnFamilies(true)
              .setReadRowkeyAsString(true)
              .setColumnFamilies(ImmutableList.of(statsSummary.build()))
              .build();

      TableId tableId = TableId.of(datasetName, tableName);
      // Create a permanent table linked to the Bigtable table
      ExternalTableDefinition externalTable =
          ExternalTableDefinition.newBuilder(sourceUri, options).build();
      bigquery.create(TableInfo.of(tableId, externalTable));

      // Example query
      TableResult results = bigquery.query(QueryJobConfiguration.of(query));

      results
          .iterateAll()
          .forEach(row -> row.forEach(val -> System.out.printf("%s,", val.toString())));

      System.out.println("Query on external permanent table performed successfully.");
    } catch (BigQueryException | InterruptedException e) {
      System.out.println("Query not performed \n" + e.toString());
    }
  }
}

Esegui query su tabelle esterne

Per ulteriori informazioni, vedi Eseguire query sui dati di Bigtable.

Schema generato

Per impostazione predefinita, BigQuery espone i valori di una famiglia di colonne come un un array di colonne e, al suo interno, un array di valori scritti in i timestamp. Questo schema conserva il layout naturale dei dati Bigtable, ma le query SQL possono essere complesse. È possibile promuovere le colonne a campi secondari all'interno della famiglia di colonne padre e in sola lettura l'ultimo valore da ogni cella. Rappresenta entrambi gli array nella schema predefinito come valori scalari.

Esempio

Stai memorizzando i profili utente per un social network fittizio. Un modello dei dati per potrebbe trattarsi di una famiglia di colonne profile con singole colonne per gender, age e email:

rowkey | profile:gender| profile:age| profile:email
-------| --------------| -----------| -------------
alice  | female        | 30         | alice@gmail.com

Usando lo schema predefinito, una query GoogleSQL per contare il numero di utenti di sesso maschile maggiore di 30 è:

SELECT
  COUNT(1)
FROM
  `dataset.table`
OMIT
  RECORD IF NOT SOME(profile.column.name = "gender"
    AND profile.column.cell.value = "male")
  OR NOT SOME(profile.column.name = "age"
    AND INTEGER(profile.column.cell.value) > 30)

L'esecuzione di query sui dati è meno complessa se gender e age sono esposti come campi. Per esporli come campi secondari, elenca gender e age come colonne con nome nella famiglia di colonne profile quando definisci la tabella. Puoi anche indicare a BigQuery per esporre i valori più recenti di questa famiglia di colonne. perché in genere solo l'ultimo valore (e probabilmente l'unico valore) è di interesse.

Dopo aver esposto le colonne come campi secondari, la query GoogleSQL conta per di utenti di sesso maschile con più di 30 anni è:

SELECT
  COUNT(1)
FROM
  `dataset.table`
WHERE
  profile.gender.cell.value="male"
  AND profile.age.cell.value > 30

Nota che a gender e age viene fatto riferimento direttamente come campi. Il file JSON configurazione per questa impostazione è:

  "bigtableOptions": {
    "readRowkeyAsString": "true",
    "columnFamilies": [
      {
          "familyId": "profile",
          "onlyReadLatest": "true",
          "columns": [
              {
                  "qualifierString": "gender",
                  "type": "STRING"
              },
              {
                  "qualifierString": "age",
                  "type": "INTEGER"
              }
          ]
      }
    ]
  }

Codifica dei valori

Bigtable archivia i dati come byte non elaborati, indipendentemente dalla codifica dei dati. Tuttavia, i valori in byte sono di uso limitato nell'analisi delle query SQL. Bigtable offre due tipi base di decodifica scalare: testo e HBase-binary.

Il formato testo presuppone che tutti i valori vengano memorizzati come stringhe di testo alfanumeriche. Ad esempio, un numero intero 768 verrà memorizzato come stringa "768". Il file binario presuppone che la codifica di HBase Bytes.toBytes di metodi precedenti per codificare i dati e applicare un'adeguata di decodifica.

Regioni e zone supportate

L'esecuzione di query sui dati in Bigtable è disponibile in tutti i prodotti supportati Zone Bigtable. Puoi trovare l'elenco di zone qui Per le istanze multi-cluster, BigQuery instrada il traffico in base Impostazioni del profilo dell'app Bigtable.

Limitazioni

Per informazioni sulle limitazioni che si applicano alle tabelle esterne, consulta Limitazioni per le tabelle esterne.

Ambiti per le istanze Compute Engine

Quando crei un'istanza Compute Engine, puoi specificare un elenco di ambiti per l'istanza. Gli ambiti controllano l'accesso dell'istanza a Google Cloud tra cui Bigtable. Applicazioni in esecuzione sulla VM Usare l'account di servizio per chiamare le API Google Cloud.

Se configuri un'istanza Compute Engine per l'esecuzione come account di servizio, e quell'account di servizio accede a una tabella esterna collegata a una Origine dati Bigtable, devi aggiungere Bigtable ambito di accesso ai dati di sola lettura (https://www.googleapis.com/auth/bigtable.data.readonly) alla in esecuzione in un'istanza Compute Engine. Per ulteriori informazioni, vedi Creazione di un'istanza Compute Engine per Bigtable.

Per informazioni sull'applicazione di ambiti a un'istanza Compute Engine, vedi Modifica dell'account di servizio e degli ambiti di accesso per un'istanza. Per ulteriori informazioni sugli account di servizio Compute Engine, consulta Account di servizio.