Diese Seite wurde von der Cloud Translation API übersetzt.

Von Apache Cassandra zu Bigtable migrieren

In diesem Dokument wird beschrieben, wie Sie Daten von Apache Cassandra zu Bigtable migrieren können, ohne dass es zu größeren Unterbrechungen kommt. Darin wird beschrieben, wie Sie Open-Source-Tools wie den Cassandra-zu-Bigtable-Proxy-Adapter oder den Cassandra-zu-Bigtable-Client für Java verwenden, um die Migration durchzuführen. Machen Sie sich zuerst mit Bigtable für Cassandra-Nutzer vertraut.

Migrationsansatz wählen

Sie können Apache Cassandra mit einem der folgenden Ansätze zu Bigtable migrieren:

Mit dem Cassandra-zu-Bigtable-Proxyadapter können Sie Cassandra-basierte Anwendungen mit Bigtable verbinden, ohne Cassandra-Treiber ändern zu müssen. Dieser Ansatz eignet sich ideal für Anwendungen, bei denen nur minimale Codeänderungen erforderlich sind.
Mit dem Cassandra-zu-Bigtable-Client für Java können Sie Bigtable direkt einbinden und Ihre Cassandra-Treiber ersetzen. Dieser Ansatz eignet sich ideal für Anwendungen, die hohe Leistung und Flexibilität erfordern.

Proxy-Adapter für Cassandra für Bigtable

Mit dem Cassandra-zu-Bigtable-Proxyadapter können Sie Cassandra-basierte Anwendungen mit Bigtable verbinden. Der Proxy-Adapter fungiert als drahtkompatible Cassandra-Schnittstelle und ermöglicht es Ihrer Anwendung, über CQL mit Bigtable zu interagieren. Bei Verwendung des Proxy-Adapters müssen Sie keine Cassandra-Treiber ändern und die Konfiguration muss nur minimal angepasst werden.

Informationen zum Einrichten und Konfigurieren des Proxy-Adapters finden Sie unter Cassandra-zu-Bigtable-Proxy-Adapter.

Informationen dazu, welche Cassandra-Versionen den Proxy-Adapter unterstützen, finden Sie unter Unterstützte Cassandra-Versionen.

Beschränkungen

Der Cassandra-zu-Bigtable-Proxyadapter bietet nur eingeschränkte Unterstützung für bestimmte Datentypen, Funktionen, Abfragen und Klauseln.

Weitere Informationen finden Sie unter Cassandra-zu-Bigtable-Proxy – Einschränkungen.

Cassandra-Schlüsselbereich

In einem Cassandra-Schlüsselbereich werden Ihre Tabellen gespeichert und Ressourcen werden ähnlich wie in einer Bigtable-Instanz verwaltet. Der Proxy-Adapter für die Migration von Cassandra zu Bigtable verarbeitet die Benennung von Schlüsselbereichen transparent, sodass Sie Abfragen mit denselben Schlüsselbereichen ausführen können. Sie müssen jedoch eine neue Bigtable-Instanz erstellen, um Ihre Tabellen logisch zu gruppieren. Sie müssen die Bigtable-Replikation auch separat konfigurieren.

DDL-Unterstützung

Der Proxy-Adapter für Cassandra zu Bigtable unterstützt DDL-Vorgänge (Data Definition Language). Mit DDL-Vorgängen können Sie Tabellen direkt über CQL-Befehle erstellen und verwalten. Wir empfehlen diesen Ansatz zum Einrichten Ihres Schemas, da er SQL ähnelt, Sie Ihr Schema aber nicht in Konfigurationsdateien definieren und dann Skripts zum Erstellen von Tabellen ausführen müssen.

Die folgenden Beispiele zeigen, wie der Proxy-Adapter für die Migration von Cassandra zu Bigtable DDL-Vorgänge unterstützt:

Führen Sie den Befehl CREATE TABLE aus, um eine Cassandra-Tabelle mit CQL zu erstellen:

CREATE TABLE keyspace.table (
    id bigint,
    name text,
    age int,
    PRIMARY KEY ((id), name)
);

Führen Sie den Befehl ALTER TABLE aus, um der Tabelle eine neue Spalte hinzuzufügen:
```
ALTER TABLE keyspace.table ADD email text;
```
Führen Sie den Befehl DROP TABLE aus, um eine Tabelle zu löschen:
```
DROP TABLE keyspace.table;
```

Weitere Informationen finden Sie unter DDL-Unterstützung für die Schemaerstellung (empfohlene Methode).

DML-Unterstützung

Der Proxy-Adapter für Cassandra zu Bigtable unterstützt DML-Vorgänge (Data Manipulation Language, Datenbearbeitungssprache) wie INSERT, DELETE, UPDATE und SELECT.

Damit die DML-Rohabfragen ausgeführt werden können, müssen alle Werte außer numerischen Werten in einfache Anführungszeichen gesetzt werden, wie in den folgenden Beispielen gezeigt:

SELECT * FROM keyspace.table WHERE name='john doe';

INSERT INTO keyspace.table (id, name) VALUES (1, 'john doe');

Migration ohne Ausfallzeiten

Sie können den Cassandra-zu-Bigtable-Proxy-Adapter mit dem Open-Source-ZDM-Proxy-Tool (Zero Downtime Migration) und dem Cassandra-Datenmigrator verwenden, um Daten mit minimaler Ausfallzeit zu migrieren.

Das folgende Diagramm zeigt die Schritte für die Migration von Cassandra zu Bigtable mit dem Proxy-Adapter:

Der Prozess der Migration von Cassandra zu Bigtable. — **Abbildung 1.** Prozess der Migration von Cassandra zu Bigtable (zum Vergrößern klicken).

**Abbildung 1.** Prozess der Migration von Cassandra zu Bigtable (zum Vergrößern klicken).

So migrieren Sie Cassandra zu Bigtable:

Verbinden Sie Ihre Cassandra-Anwendung mit dem ZDM-Proxy-Tool.
Aktivieren Sie Dual-Writes für Cassandra und Bigtable.
Verschieben Sie Daten mit dem Tool Cassandra Data Migrator in großen Mengen.
Migration validieren Nach der Validierung können Sie die Verbindung zu Cassandra beenden und direkt eine Verbindung zu Bigtable herstellen.

Wenn Sie den Proxy-Adapter mit dem ZDM-Proxy-Tool verwenden, werden die folgenden Migrationsfunktionen unterstützt:

Duale Schreibvorgänge: Datenverfügbarkeit während der Migration aufrechterhalten
Asynchrone Lesevorgänge: Bigtable-Instanz skalieren und Stresstests durchführen
Automatisierte Datenüberprüfung und Berichterstellung: Datenintegrität während des gesamten Prozesses sicherstellen
Datenzuordnung: Felder und Datentypen zuordnen, um Produktionsstandards zu erfüllen

Wenn Sie die Migration von Cassandra zu Bigtable üben möchten, sehen Sie sich das Codelab zur Migration von Cassandra zu Bigtable mit einem Dual-Write-Proxy an.

Cassandra-zu-Bigtable-Client für Java

Sie können Cassandra-basierte Java-Anwendungen direkt in Bigtable einbinden und Ihre Cassandra-Treiber ersetzen. Mit der Clientbibliothek „Cassandra to Bigtable“ für Java können Sie Cassandra-basierte Java-Anwendungen mit CQL in Bigtable einbinden.

Eine Anleitung zum Erstellen der Bibliothek und zum Einbinden der Abhängigkeit in den Anwendungscode finden Sie unter Cassandra to Bigtable Client for Java.

Im folgenden Beispiel wird gezeigt, wie Sie Ihre Anwendung mit dem Cassandra-zu-Bigtable-Client für Java konfigurieren:

import com.datastax.oss.driver.api.core.CqlSession;
import com.datastax.oss.driver.api.core.cql.BoundStatement;
import com.datastax.oss.driver.api.core.cql.PreparedStatement;
import com.datastax.oss.driver.api.core.cql.ResultSet;
import com.datastax.oss.driver.api.core.cql.Row;
import com.google.bigtable.cassandra.BigtableCqlConfiguration;
import com.google.bigtable.cassandra.BigtableCqlSessionFactory;

/**
 * Example using Bigtable CQLSession
 */
public class ExampleWithBigtableCqlSession {

  public static void main(String[] args) {

    // Construct BigtableCqlConfiguration
    BigtableCqlConfiguration bigtableCqlConfiguration = BigtableCqlConfiguration.builder()
        .setProjectId("example-project-id")
        .setInstanceId("example-instance-id")
        .setDefaultColumnFamily("example-column-family")
        .setBigtableChannelPoolSize(4)
        .build();

    // Create CqlSession with BigtableCqlConfiguration
    BigtableCqlSessionFactory bigtableCqlSessionFactory = new BigtableCqlSessionFactory(bigtableCqlConfiguration);

    // Create CqlSession
    try (CqlSession session = bigtableCqlSessionFactory.newSession()) {

      // Create a table
      String createTableQuery = "CREATE TABLE <KEYSPACE>.<TABLE_NAME> (<COLUMN> <TYPE> PRIMARY KEY);";
      session.execute(createTableQuery);

      // Prepare an insert statement
      PreparedStatement preparedInsert = session.prepare(
          "INSERT INTO <KEYSPACE>.<TABLE_NAME> (<COLUMN>) VALUES (?)" // replace with your keyspace, table and columns
      );

      // Insert
      BoundStatement boundInsert = preparedInsert
          .bind()
          .setString("<COLUMN>", "<VALUE>");
      session.execute(boundInsert);

      // Query for all entries
      ResultSet resultSet = session.execute("SELECT <COLUMN> FROM <KEYSPACE>.<TABLE_NAME>;");
      // Print results
      for (Row row : resultSet) {
        System.out.println(row);
      }

    }

  }

}ExampleWithBigtableCqlSession.java

Leistung nachvollziehen

Bigtable ist für hohen Durchsatz, niedrige Latenz und massive Skalierbarkeit konzipiert. Es kann Millionen von Anfragen pro Sekunde für Petabytes von Daten verarbeiten. Wenn Sie von Cassandra migrieren und entweder den Cassandra-zu-Bigtable-Client für Java oder den Cassandra-zu-Bigtable-Proxyadapter verwenden, sollten Sie die folgenden Auswirkungen auf die Leistung beachten:

Client- und Proxy-Overhead

Beide Migrationsansätze verursachen nur einen minimalen Leistungsaufwand. Sie fungieren als Übersetzungsebene zwischen der Cassandra Query Language (CQL) und der Bigtable Data API, die für Effizienz optimiert ist.

Leistung mit Cassandra-Sammlungstypen

Wenn in Ihrem Cassandra-Datenmodell Sammlungstypen wie Maps, Sets oder Listen verwendet werden, um dynamische Schemas zu implementieren, kann Bigtable diese Muster effektiv verarbeiten. Sowohl der Proxy-Adapter als auch der Client für Java bilden diese Sammlungsvorgänge auf das zugrunde liegende Datenmodell von Bigtable ab, das sich gut für spärliche und breite Datasets eignet.

Vorgänge auf Elementebene in diesen Sammlungen sind sehr effizient. Dazu gehören die folgenden Aktionen:

So lesen oder schreiben Sie einen einzelnen Wert in einer Map.
So fügen Sie einem Set ein Element hinzu oder entfernen es daraus.
So fügen Sie ein Element an eine Liste an oder stellen es voran.

Bigtable optimiert diese Arten von Punktoperationen für einzelne Sammlungselemente. Ihre Leistung ist identisch mit Operationen für standardmäßige skalare Spalten.

Arbeitslast benchmarken

Die Bigtable-Leistung kann je nach Arbeitslast, Schemadesign, Datenzugriffsmustern und Clusterkonfiguration variieren. Um genaue Leistungsmesswerte für Ihren Anwendungsfall zu erhalten und sicherzustellen, dass Bigtable Ihren spezifischen Anforderungen entspricht, empfehlen wir, Ihre Cassandra-Arbeitslasten mit einem der Migrationsansätze mit Bigtable zu vergleichen.

Weitere Informationen zu Best Practices für die Bigtable-Leistung finden Sie unter Leistung verstehen.

Zusätzliche Cassandra-Open-Source-Tools

Aufgrund der Wire-Kompatibilität des Cassandra-zu-Bigtable-Proxy-Adapters mit CQL können Sie zusätzliche Tools aus dem Cassandra-Open-Source-Ökosystem verwenden. Dazu gehören:

Cqlsh: Mit der CQL-Shell können Sie über den Proxy-Adapter direkt eine Verbindung zu Bigtable herstellen. Sie können es für das Debugging und schnelle Datensuchen mit CQL verwenden.
Cassandra Data Migrator (CDM): Dieses Spark-basierte Tool eignet sich für die Migration großer Mengen (bis zu Milliarden von Zeilen) von Verlaufsdaten. Das Tool bietet Validierungs-, Differenzberichts- und Wiedergabefunktionen und ist vollständig mit dem Proxy-Adapter kompatibel.

Nächste Schritte

Best Practices für Schemadesign