Externe Bigtable-Tabelle erstellen

Auf dieser Seite wird beschrieben, wie Sie eine permanente externe BigQuery-Tabelle erstellen, die zum Abfragen von in Bigtable gespeicherten Daten verwendet werden kann. Das Abfragen von Daten in Bigtable ist an allen Bigtable-Standorten verfügbar.

Hinweis

Sammeln Sie vor dem Erstellen einer externen Tabelle einige Informationen und prüfen Sie, ob Sie die Berechtigung zum Erstellen der Tabelle haben.

Erforderliche Rollen

Um eine externe Tabelle zum Abfragen Ihrer Bigtable-Daten erstellen zu können, müssen Sie ein Hauptkonto in der Rolle "Bigtable-Administrator" (roles/bigtable.admin) für die Instanz sein, die die Quelltabelle enthält.

Außerdem benötigen Sie die BigQuery-Berechtigung bigquery.tables.create (Identity and Access Management).

Jede der folgenden vordefinierten Rollen für das Identity and Access Management enthält diese Berechtigung:

BigQuery Datenmitbearbeiter (roles/bigquery.dataEditor)
BigQuery Dateninhaber (roles/bigquery.dataOwner)
BigQuery Administrator (roles/bigquery.admin)

Wenn Sie in keiner dieser Rollen ein Hauptkonto sind, bitten Sie Ihren Administrator, Ihnen Zugriff zu gewähren oder die externe Tabelle für Sie zu erstellen.

Weitere Informationen zu Rollen und Berechtigungen für das Identity and Access Management in BigQuery finden Sie unter Vordefinierte Rollen und Berechtigungen. Informationen zu Bigtable-Berechtigungen finden Sie unter Zugriffssteuerung mit Identity and Access Management.

Dataset erstellen oder identifizieren

Bevor Sie eine externe Tabelle erstellen, müssen Sie ein Dataset erstellen, das die externe Tabelle enthält. Sie können auch ein vorhandenes Dataset verwenden.

Optional: Cluster festlegen oder erstellen

Wenn Sie häufig dieselben Daten abfragen möchten, die Ihrer Produktionsanwendung zugeordnet sind, empfehlen wir, in Ihrer Bigtable-Instanz einen Cluster für die Analyse in BigQuery festzulegen. Dadurch wird der Traffic von dem oder den Clustern isoliert, die Sie für die Lese- und Schreibvorgänge Ihrer Anwendung verwenden. Weitere Informationen zur Replikation und zum Erstellen von Instanzen mit mehr als einem Cluster finden Sie unter Replikation.

Anwendungsprofil ermitteln oder erstellen

Entscheiden Sie vor dem Erstellen einer externen Tabelle, welches Bigtable-Anwendungsprofil von BigQuery zum Lesen der Daten verwendet werden soll. Wir empfehlen die Verwendung eines Anwendungsprofils, das Sie für die Verwendung mit BigQuery festlegen.

Wenn Sie in Ihrer Bigtable-Instanz einen Cluster für den BigQuery-Zugriff haben, konfigurieren Sie das Anwendungsprofil für die Verwendung von Single-Cluster-Routing zu diesem Cluster.

Weitere Informationen zur Funktionsweise von Bigtable-Anwendungsprofilen finden Sie unter Anwendungsprofile. Informationen zum Erstellen eines neuen Anwendungsprofils finden Sie unter Anwendungsprofile erstellen und konfigurieren.

Bigtable-URI abrufen

Um eine externe Tabelle für eine Bigtable-Datenquelle zu erstellen, müssen Sie den Bigtable-URI angeben. So rufen Sie den Bigtable-URI ab:

Öffnen Sie in der Console die Seite "Bigtable".

Zu Bigtable wechseln
Rufen Sie die folgenden Details über Ihre Bigtable-Datenquelle ab:
- Ihre Projekt-ID
- Ihre Bigtable-Instanz-ID
- Die ID des Bigtable-Anwendungsprofils, das Sie verwenden möchten
- Den Namen Ihrer Bigtable-Tabelle
Kombinieren Sie den Bigtable-URI im folgenden Format. Dabei gilt:
- project_id ist das Projekt, das Ihre Bigtable-Instanz enthält.
- instance_id ist die Bigtable-Instanz-ID.
- Optional: app_profile ist die zu verwendende Anwendungsprofil-ID.
- table_name ist der Name der abzufragenden Tabelle.
https://googleapis.com/bigtable/projects/project_id/instances/instance_id[/appProfiles/app_profile]/tables/table_name

Permanente externe Tabellen erstellen

Wenn Sie in BigQuery eine permanente externe Tabelle erstellen, die mit einer Bigtable-Datenquelle verknüpft ist, gibt es zwei Möglichkeiten, um das Format der externen Tabelle anzugeben:

Wenn Sie die API oder das bq-Befehlszeilentool verwenden, erstellen Sie eine Tabellendefinitionsdatei, in der Sie das Schema und die Metadaten der externen Tabelle definieren.
Wenn Sie SQL verwenden, verwenden Sie die uri-Option der CREATE EXTERNAL TABLE-Anweisung, um die Bigtable-Tabelle zum Abrufen von Daten anzugeben, und die bigtable_options-Option, um das Tabellenschema anzugeben.

Die externen Tabellendaten werden nicht in der BigQuery-Tabelle gespeichert. Da die Tabelle permanent ist, können Sie sie mithilfe der Zugriffssteuerung auf Dataset-Ebene für andere Nutzer freigeben, die ebenfalls Zugriff auf die zugrunde liegende Bigtable-Datenquelle haben.

Zum Erstellen einer permanenten Tabelle wählen Sie eine der folgenden Methoden aus.

SQL

Sie können eine permanente externe Tabelle erstellen, indem Sie die CREATE EXTERNAL TABLEDDL-Anweisung ausführen. Sie müssen das Tabellenschema explizit als Teil der Anweisungsoptionen angeben.

Öffnen Sie in der Google Cloud Console die Seite BigQuery.

BigQuery aufrufen
Geben Sie im Abfrageeditor die folgende Anweisung ein:
```
CREATE EXTERNAL TABLE DATASET.NEW_TABLE
OPTIONS (
  format = 'CLOUD_BIGTABLE',
  uris = ['URI'],
  bigtable_options = BIGTABLE_OPTIONS );
```
Dabei gilt:
- DATASET ist das Dataset, in dem die externe Bigtable-Tabelle erstellt werden soll.
- NEW_TABLE ist der Name der externen Bigtable-Tabelle.
- URI ist der URI der Bigtable-Tabelle, die Sie als Datenquelle verwenden möchten. Dieser URI muss dem unter Bigtable-URI abrufen beschriebenen Format entsprechen.
- BIGTABLE_OPTIONS ist das Schema für die Bigtable-Tabelle im JSON-Format. Eine Liste der Optionen für Bigtable-Tabellendefinitionen finden Sie in der REST API-Referenz unter BigtableOptions.
Klicken Sie auf Ausführen.

Informationen zum Ausführen von Abfragen finden Sie unter Interaktive Abfrage ausführen.

Eine Anweisung zum Erstellen einer externen Bigtable-Tabelle könnte etwa so aussehen:

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

Sie erstellen eine Tabelle im bq-Befehlszeilentool mit dem Befehl bq mk. Wenn Sie mit dem bq-Befehlszeilentool eine Tabelle erstellen, die mit einer externen Datenquelle verknüpft ist, können Sie das Schema der Tabelle mit einer Tabellendefinitionsdatei identifizieren:

Zum Erstellen einer permanente Tabelle verwenden Sie den Befehl bq mk.
```
bq mk \
--external_table_definition=DEFINITION_FILE \
DATASET.TABLE
```
Dabei gilt:
- DEFINITION_FILE: der Pfad zur Tabellendefinitionsdatei auf Ihrem lokalen Rechner.
- DATASET: der Name des Datasets, das die Tabelle enthält.
- TABLE: Der Name der Tabelle, die Sie erstellen.

API

Verwenden Sie dietables.insert API-Methode und erstellen Sie eineExternalDataConfiguration in der Table-Ressource, die Sie übergeben.

Geben Sie für das sourceUris-Attribut in der Ressource Table nur einen Bigtable-URI an. Es muss ein gültiger HTTPS-URL sein.

Geben Sie für das sourceFormat-Attribut "BIGTABLE" an.

Java

Bevor Sie dieses Beispiel anwenden, folgen Sie den Schritten zur Einrichtung von Java in der BigQuery-Kurzanleitung zur Verwendung von Clientbibliotheken. Weitere Angaben finden Sie in der Referenzdokumentation zur BigQuery Java API.

Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten.

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

Externe Tabellen abfragen

Weitere Informationen finden Sie unter Daten in Bigtable abfragen.

Generiertes Schema

Standardmäßig stellt BigQuery die Werte in einer Spaltenfamilie als Array von Spalten bereit, das wiederum ein Array von Werten enthält, die mit verschiedenen Zeitstempeln versehen sind. Durch dieses Schema wird das ursprüngliche Layout der Daten in Bigtable bewahrt, aber die SQL-Abfragen können recht schwierig sein. Es ist möglich, Spalten in Teilfeldern innerhalb der übergeordneten Spaltenfamilie zu platzieren und nur den neuesten Wert aus jeder Zelle zu lesen. Dabei werden beide Arrays im Standardschema als skalare Werte dargestellt.

Beispiel

Angenommen, Sie speichern Nutzerprofile für ein fiktives soziales Netzwerk. Ein mögliches Datenmodell dafür wäre die Spaltenfamilie profile mit einzelnen Spalten für gender, age und email:

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

Mithilfe des Standardschemas könnte mit einer GoogleSQL-Abfrage die Anzahl der männlichen Nutzer über 30 so abgefragt werden:

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)

Das Abfragen der Daten ist weniger schwierig, wenn gender und age als Teilfelder bereitgestellt werden. Wenn Sie diese Werte als Teilfelder bereitstellen möchten, listen Sie gender und age beim Definieren der Tabelle in der Spaltenfamilie profile als benannte Spalten auf. Sie können BigQuery auch anweisen, die neuesten Werte aus dieser Spaltenfamilie bereitzustellen, da in der Regel nur der neueste (und möglicherweise einzige) Wert von Interesse ist.

Wenn Sie die Spalten als Teilfelder bereitstellen, sieht die GoogleSQL-Abfrage zur Zählung der männlichen Nutzer über 30 so aus:

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

Beachten Sie, dass gender und age direkt als Felder angegeben sind. Die JSON-Konfiguration für dieses Szenario sieht so aus:

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

Wertcodierung

Unabhängig von der Datencodierung speichert Bigtable Daten als Rohbyte. Bytewerte sind jedoch bei der Analyse mithilfe von SQL-Abfragen nur beschränkt hilfreich. Bigtable bietet zwei grundlegende Arten der Decodierung skalarer Werte: Text und HBase-binär.

Beim Textformat wird angenommen, dass alle Werte als alphanumerische Textstrings gespeichert sind. Die Ganzahl 768 wird z. B. als der String "768" gespeichert. Bei der binären Codierung wird angenommen, dass die Daten mithilfe der Methodenklasse Bytes.toBytes von HBase codiert wurden. Daher wird eine entsprechende Decodierungsmethode angewendet.

Unterstützte Regionen und Zonen

Das Abfragen von Daten in Bigtable ist in allen unterstützten Bigtable-Zonen verfügbar. Eine Liste der Zonen finden Sie hier. Bei Multi-Cluster-Instanzen leitet BigQuery den Traffic anhand der Anwendungsprofileinstellungen von Bigtable weiter.

Beschränkungen

Informationen zu Einschränkungen für externe Tabellen finden Sie unter Einschränkungen für externe Tabellen.

Bereiche für Compute Engine-Instanzen

Wenn Sie eine Compute Engine-Instanz erstellen, können Sie eine Liste der Bereiche für die Instanz festlegen. Mit den Bereichen steuern Sie den Zugriff der Instanz auf Google Cloud-Produkte wie Bigtable. Auf der VM ausgeführte Anwendungen rufen Google Cloud APIs über das Dienstkonto auf.

Wenn Sie eine Compute Engine-Instanz einrichten, die als Dienstkonto ausgeführt werden soll, und das Dienstkonto auf eine externe Tabelle zugreift, die mit einer Bigtable-Datenquelle verknüpft ist, müssen Sie der Instanz den schreibgeschützten Datenzugriffsbereich von Bigtable hinzufügen (https://www.googleapis.com/auth/bigtable.data.readonly). Weitere Informationen finden Sie unter OAuth-Bereiche für Bigtable.

Wie Sie Bereiche auf eine Compute Engine-Instanz anwenden, erfahren Sie unter Dienstkonto und Zugriffsbereiche für eine Instanz ändern. Weitere Informationen zu Compute Engine-Dienstkonten finden Sie unter Dienstkonten.