Crea una tabella esterna Bigtable

Questa pagina descrive come creare una tabella esterna permanente BigQuery che può essere utilizzata per eseguire query sui dati archiviati in Bigtable. L'esecuzione di query sui dati in Bigtable è disponibile in tutte le località Bigtable.

Prima di iniziare

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

Ruoli obbligatori

Per creare una tabella esterna da utilizzare per eseguire query sui dati Bigtable, devi essere un principal con il ruolo Bigtable Admin (roles/bigtable.admin) per l'istanza che contiene la tabella di origine.

Devi anche disporre dell'autorizzazione bigquery.tables.create BigQuery Identity and Access Management (IAM).

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

• Editor dati BigQuery (roles/bigquery.dataEditor)
• BigQuery Data Owner (roles/bigquery.dataOwner)
• Amministratore BigQuery (roles/bigquery.admin)

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

Per ulteriori informazioni su ruoli e autorizzazioni di Identity and Access Management in BigQuery, consulta Ruoli e autorizzazioni predefiniti. Per visualizzare informazioni sulle autorizzazioni Bigtable, consulta Controllo dell'accesso con Identity and Access Management. Per visualizzare i ruoli richiesti per eseguire query sulla tabella esterna, consulta Eseguire query sui dati Bigtable.

Creare o identificare un set di dati

Prima di creare una tabella esterna, devi creare un set di dati che la contenga. Puoi anche utilizzare un set di dati esistente.

Pianificare l'utilizzo di risorse di calcolo

Determina il tipo di calcolo che vuoi utilizzare quando esegui query sui dati. Specifichi che vuoi utilizzare Data Boost o che vuoi eseguire il routing a un cluster dedicato nelle impostazioni del profilo dell'app.

Data Boost

Per evitare di influire sul traffico di pubblicazione delle applicazioni, puoi utilizzare il serverless computing di Data Boost quando utilizzi una tabella esterna BigQuery per leggere i dati Bigtable. Per utilizzare Data Boost, devi utilizzare un profilo dell'app Data Boost e includere l'ID del profilo dell'app quando componi l'URI Bigtable. Per saperne di più su Data Boost, consulta la panoramica di Bigtable Data Boost.

Nodi di cui è stato eseguito il provisioning

Se non utilizzi Data Boost, per il computing vengono utilizzati i nodi del cluster.

Se non utilizzi Data Boost e prevedi di eseguire spesso query sugli stessi dati che servono alla tua applicazione di produzione, ti consigliamo di designare un cluster nella tua istanza Bigtable da utilizzare esclusivamente per l'analisi BigQuery. In questo modo, il traffico viene isolato dal cluster o dai cluster che utilizzi per le letture e le scritture della tua applicazione. Per saperne di più sulla replica e sulla creazione di istanze con più di un cluster, consulta Informazioni sulla replica.

Identificare o creare un profilo dell'app

Prima di creare una tabella esterna, decidi quale profilo app Bigtable deve utilizzare BigQuery per leggere i dati. Ti consigliamo di utilizzare un profilo app designato per l'utilizzo esclusivo con BigQuery. Il profilo dell'app può essere un profilo dell'app standard o un profilo dell'app Data Boost, a seconda del tipo di calcolo che vuoi utilizzare per eseguire query sui dati.

Se nella tua istanza Bigtable hai un cluster dedicato all'accesso BigQuery, configura il profilo app in modo che utilizzi il routing a cluster singolo a quel cluster.

Per utilizzare il serverless computing di Data Boost, crea un profilo dell'app Data Boost. Per utilizzare i nodi del cluster per il calcolo, crea un profilo dell'app standard. Per scoprire come funzionano i profili app Bigtable, vedi Informazioni sui profili app. Per scoprire come creare un nuovo profilo di app, vedi Creazione e configurazione di profili di app.

Recupera l'URI Bigtable

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

1. Apri la pagina Bigtable nella console.

   Vai a Bigtable

2. Recupera i seguenti dettagli sull'origine dati Bigtable:

   • L'ID progetto.
   • L'ID istanza Bigtable.
   • L'ID del profilo app Bigtable che prevedi di utilizzare. Può trattarsi di un profilo dell'app standard o di un profilo dell'app Data Boost, a seconda del tipo di calcolo che vuoi utilizzare. Se non specifichi un ID profilo app, viene utilizzato il profilo app predefinito.
   • Il nome della tabella Bigtable.

3. Componi l'URI Bigtable utilizzando il seguente formato, dove:

   • PROJECT_ID è il progetto che contiene l'istanza Bigtable
   • INSTANCE_ID è l'ID istanza Bigtable
   • APP_PROFILE (facoltativo) è l'identificatore del profilo app che vuoi utilizzare
   • TABLE_NAME è il nome della tabella su cui stai eseguendo query

   https://googleapis.com/bigtable/projects/PROJECT_ID/instances/INSTANCE_ID[/appProfiles/APP_PROFILE]/tables/TABLE_NAME

Creare tabelle esterne permanenti

Quando crei una tabella esterna permanente in BigQuery collegata a un'origine dati Bigtable, hai due opzioni per specificare il formato della tabella esterna:

• Se utilizzi l'API o lo strumento a riga di comando bq, crea un file di definizione della tabella che definisce lo schema e i metadati per la tabella esterna.
• Se utilizzi SQL, usa l'opzione uri dell'istruzione CREATE EXTERNAL TABLE per specificare la tabella Bigtable da cui estrarre i dati e 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 i controlli dell'accesso a livello di set di dati per condividerla con altri utenti che hanno anche accesso all'origine dati Bigtable sottostante.

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

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

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());
    }
  }
}

Eseguire query sulle tabelle esterne

Per maggiori informazioni, consulta Eseguire query sui dati Bigtable.

Schema generato

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

Esempio

Stai archiviando i profili utente per un social network fittizio. Un modello dei dati per questo potrebbe essere una famiglia di colonne profile con colonne individuali per gender, age e email:

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

Utilizzando lo schema predefinito, una query GoogleSQL per conteggiare il numero di utenti di sesso maschile di età superiore a 30 anni è:

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 secondari. Per esporli come campi secondari, elenca gender e age come colonne denominate nella famiglia di colonne profile durante la definizione della tabella. Puoi anche chiedere a BigQuery di esporre gli ultimi valori di questa famiglia di colonne perché in genere è interessante solo l'ultimo valore (e forse l'unico).

Dopo aver esposto le colonne come campi secondari, la query GoogleSQL per conteggiare il numero di utenti di sesso maschile di età superiore a 30 anni è:

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

Nota come gender e age vengono indicati direttamente come campi. La configurazione JSON per questa configurazione è:

  "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 dei byte sono di utilità limitata nell'analisi delle query SQL. Bigtable fornisce due tipi di decodifica scalare di base: testo e binario HBase.

Il formato di testo presuppone che tutti i valori siano memorizzati come stringhe di testo alfanumeriche. Ad esempio, un numero intero 768 verrà memorizzato come stringa "768". La codifica binaria presuppone che per codificare i dati sia stata utilizzata la classe di metodi Bytes.toBytes di HBase e applica un metodo di decodifica appropriato.

Regioni e zone supportate

L'esecuzione di query sui dati in Bigtable è disponibile in tutte le zone Bigtable supportate. Puoi trovare l'elenco delle zone qui. Per le istanze multicluster, BigQuery instrada il traffico in base alle impostazioni del profilo dell'app Bigtable.

Limitazioni

• Non puoi creare tabelle esterne su oggetti basati su Bigtable SQL, come viste e viste materializzate continue.
• Per ulteriori informazioni sulle limitazioni applicabili alle tabelle esterne, vedi Limitazioni delle tabelle esterne.

Ambiti per le istanze di Compute Engine

Quando crei un'istanza Compute Engine, puoi specificare un elenco di ambiti per l'istanza. Gli ambiti controllano l'accesso dell'istanza ai prodotti, incluso Bigtable. Google CloudLe applicazioni in esecuzione sulla VM utilizzano l'account di servizio per chiamare le API di Google Cloud .

Se configuri un'istanza Compute Engine da eseguire come service account e questo account di servizio accede a una tabella esterna collegata a un'origine dati Bigtable, devi aggiungere all'istanza l'ambito di accesso ai dati di sola lettura Bigtable (https://www.googleapis.com/auth/bigtable.data.readonly). Per saperne di più, consulta Creazione di un'istanza Compute Engine per Bigtable.

Per informazioni sull'applicazione degli ambiti a un'istanza Compute Engine, consulta Modifica del account di servizio e degli ambiti di accesso per un'istanza. Per ulteriori informazioni sui service account Compute Engine, consulta Service account.

Passaggi successivi

• Scopri di più sulla progettazione dello schema Bigtable.
• Leggi l'introduzione alle origini dati esterne.