Direktmigrering till Azure Managed Instance för Apache Cassandra med hjälp av en proxy med dubbel skrivning

Om möjligt rekommenderar vi att du använder den inbyggda Apache Cassandra-funktionen för att migrera data från ditt befintliga kluster till Azure Managed Instance för Apache Cassandra genom att konfigurera ett hybridkluster. Den här funktionen använder Apache Cassandras skvallerprotokoll för att replikera data från ditt källdatacenter till ditt nya hanterade instansdatacenter på ett sömlöst sätt. Det kan dock finnas vissa scenarier där din källdatabasversion inte är kompatibel, eller så är det inte möjligt att konfigurera ett hybridkluster.

I den här självstudien beskrivs hur du migrerar data till Azure Managed Instance för Apache Cassandra live med hjälp av en proxy med dubbla skrivningar och Apache Spark. Proxyn med dubbel skrivning används för att samla in liveändringar, medan historiska data kopieras i grupp med hjälp av Apache Spark. Fördelarna med den här metoden är:

• Minimala programändringar. Proxyn kan acceptera anslutningar från programkoden med få eller inga konfigurationsändringar. Den dirigerar alla begäranden till källdatabasen och dirigerar skrivningar asynkront till ett sekundärt mål.
• Klient trådprotokoll beroende. Eftersom den här metoden inte är beroende av backend-resurser eller interna protokoll kan den användas med alla Cassandra-käll- eller målsystem som implementerar Apache Cassandra-trådprotokollet.

Följande bild illustrerar metoden.

Förutsättningar

• Etablera en Azure Managed Instance för Apache Cassandra-kluster med hjälp Azure Portal eller Azure CLI. Kontrollera att du kan ansluta till klustret med CQLSH.

• Etablera ett Azure Databricks i det hanterade virtuella Cassandra-nätverket. Kontrollera att kontot har nätverksåtkomst till cassandra-källklustret. Vi skapar ett Spark-kluster i det här kontot för den historiska databelastningen.

• Se till att du redan har migrerat keyspace/table-schemat från Cassandra-källdatabasen till cassandra-databasen för den hanterade Cassandra-instansen.

Etablera ett Spark-kluster

Vi rekommenderar att Azure Databricks version 7.5, som stöder Spark 3.0.

Lägga till Spark-beroenden

Du måste lägga till biblioteket Apache Spark Cassandra Connector i klustret för att ansluta till alla trådprotokollkompatibla Apache Cassandra-slutpunkter. I klustret väljer du Bibliotek Installera > ny > Maven och lägger sedan till com.datastax.spark:spark-cassandra-connector-assembly_2.12:3.0.0 i Maven-koordinater.

Välj Installera och starta sedan om klustret när installationen är klar.

Installera proxyn med dubbel skrivning

För optimala prestanda vid dubbla skrivningar rekommenderar vi att du installerar proxyn på alla noder i Cassandra-källklustret.

#assuming you do not have git already installed
sudo apt-get install git 

#assuming you do not have maven already installed
sudo apt install maven

#clone repo for dual-write proxy
git clone https://github.com/Azure-Samples/cassandra-proxy.git

#change directory
cd cassandra-proxy

#compile the proxy
mvn package

Starta proxyn med dubbel skrivning

Vi rekommenderar att du installerar proxyn på alla noder i Cassandra-källklustret. Kör minst följande kommando för att starta proxyn på varje nod. Ersätt <target-server> med en IP- eller serveradress från en av noderna i målklustret. Ersätt <path to JKS file> med sökvägen till en lokal .jks-fil och <keystore password> ersätt med motsvarande lösenord.

java -jar target/cassandra-proxy-1.0-SNAPSHOT-fat.jar localhost <target-server> --proxy-jks-file <path to JKS file> --proxy-jks-password <keystore password>

När proxyn startas på det här sättet förutsätts att följande är sant:

• Käll- och målslutpunkter har samma användarnamn och lösenord.
• Käll- och målslutpunkter implementerar Secure Sockets Layer (SSL).

Om dina käll- och målslutpunkter inte kan uppfylla dessa kriterier kan du läsa vidare för ytterligare konfigurationsalternativ.

Konfigurera SSL

För SSL kan du antingen implementera ett befintligt nyckellager (till exempel det som källklustret använder) eller skapa ett själv signerat certifikat med hjälp av keytool :

keytool -genkey -keyalg RSA -alias selfsigned -keystore keystore.jks -storepass password -validity 360 -keysize 2048

Du kan också inaktivera SSL för käll- eller målslutpunkter om de inte implementerar SSL. Använd --disable-source-tls --disable-target-tls flaggorna eller :

java -jar target/cassandra-proxy-1.0-SNAPSHOT-fat.jar localhost <target-server> --source-port 9042 --target-port 10350 --proxy-jks-file <path to JKS file> --proxy-jks-password <keystore password> --target-username <username> --target-password <password> --disable-source-tls true  --disable-target-tls true 

Konfigurera autentiseringsuppgifter och port

Som standard skickas autentiseringsuppgifterna för källan via din klientapp. Proxyn använder autentiseringsuppgifterna för att skapa anslutningar till käll- och målkluster. Som tidigare nämnts förutsätter den här processen att käll- och målautentiseringsuppgifterna är desamma. Om det behövs kan du ange ett annat användarnamn och lösenord för Cassandra-målslutpunkten separat när du startar proxyn:

java -jar target/cassandra-proxy-1.0-SNAPSHOT-fat.jar localhost <target-server> --proxy-jks-file <path to JKS file> --proxy-jks-password <keystore password> --target-username <username> --target-password <password>

Standardportarna för källa och mål är 9042 när de inte anges. Om antingen målet eller Cassandra-källslutpunkten körs på en annan port kan du använda --source-port eller för att ange ett annat --target-port portnummer:

java -jar target/cassandra-proxy-1.0-SNAPSHOT-fat.jar localhost <target-server> --source-port 9042 --target-port 10350 --proxy-jks-file <path to JKS file> --proxy-jks-password <keystore password> --target-username <username> --target-password <password>

Distribuera proxyn via fjärrinstallation

Det kan finnas omständigheter då du inte vill installera proxyn på själva klusternoderna och du föredrar att installera den på en separat dator. I det scenariot måste du ange IP-adressen för <source-server> :

java -jar target/cassandra-proxy-1.0-SNAPSHOT-fat.jar <source-server> <destination-server>

Tillåt noll ändringar i programkoden

Som standard lyssnar proxyn på port 29042. Programkoden måste ändras så att den pekar på den här porten. Du kan dock ändra den port som proxyn lyssnar på. Du kan göra detta om du vill eliminera kodändringar på programnivå genom att:

• Att Cassandra-källservern körs på en annan port.
• Låt proxyn köras på Cassandra-standardporten 9042.

java -jar target/cassandra-proxy-1.0-SNAPSHOT-fat.jar source-server destination-server --proxy-port 9042

java -jar target/cassandra-proxy-1.0-SNAPSHOT-fat.jar source-server destination-server --proxy-port 9042 --source-port 3074

Tvinga protokoll

Proxyn har funktioner för att tvinga protokoll, vilket kan vara nödvändigt om källslutpunkten är mer avancerad än målet eller på annat sätt inte stöds. I så fall kan du ange --protocol-version och för att tvinga protokollet att följa --cql-version målet:

java -jar target/cassandra-proxy-1.0-SNAPSHOT-fat.jar source-server destination-server --protocol-version 4 --cql-version 3.11

När proxyn med dubbel skrivning körs måste du ändra porten på programklienten och starta om. (Eller ändra Cassandra-porten och starta om klustret om du har valt den metoden.) Proxyn börjar sedan vidarebefordra skrivningar till målslutpunkten. Du kan lära dig mer om övervakning och mått som är tillgängliga i proxyverktyget.

Köra den historiska databelastningen

Om du vill läsa in data skapar du en Scala-notebook-Azure Databricks konto. Ersätt dina Cassandra-käll- och målkonfigurationer med motsvarande autentiseringsuppgifter och ersätt käll- och målnyckelutrymmena och tabellerna. Lägg till fler variabler för varje tabell efter behov i följande exempel och kör sedan. När programmet börjar skicka begäranden till proxyn med dubbla skrivningar är du redo att migrera historiska data.

import com.datastax.spark.connector._
import com.datastax.spark.connector.cql._
import org.apache.spark.SparkContext

// source cassandra configs
val sourceCassandra = Map( 
    "spark.cassandra.connection.host" -> "<Source Cassandra Host>",
    "spark.cassandra.connection.port" -> "9042",
    "spark.cassandra.auth.username" -> "<USERNAME>",
    "spark.cassandra.auth.password" -> "<PASSWORD>",
    "spark.cassandra.connection.ssl.enabled" -> "true",
    "keyspace" -> "<KEYSPACE>",
    "table" -> "<TABLE>"
)

//target cassandra configs
val targetCassandra = Map( 
    "spark.cassandra.connection.host" -> "<Source Cassandra Host>",
    "spark.cassandra.connection.port" -> "9042",
    "spark.cassandra.auth.username" -> "<USERNAME>",
    "spark.cassandra.auth.password" -> "<PASSWORD>",
    "spark.cassandra.connection.ssl.enabled" -> "true",
    "keyspace" -> "<KEYSPACE>",
    "table" -> "<TABLE>",
    //throughput related settings below - tweak these depending on data volumes. 
    "spark.cassandra.output.batch.size.rows"-> "1",
    "spark.cassandra.output.concurrent.writes" -> "1000",
    "spark.cassandra.connection.remoteConnectionsPerExecutor" -> "1",
    "spark.cassandra.concurrent.reads" -> "512",
    "spark.cassandra.output.batch.grouping.buffer.size" -> "1000",
    "spark.cassandra.connection.keep_alive_ms" -> "600000000"
)

//set timestamp to ensure it is before read job starts
val timestamp: Long = System.currentTimeMillis / 1000

//Read from source Cassandra
val DFfromSourceCassandra = sqlContext
  .read
  .format("org.apache.spark.sql.cassandra")
  .options(sourceCassandra)
  .load
  
//Write to target Cassandra
DFfromSourceCassandra
  .write
  .format("org.apache.spark.sql.cassandra")
  .options(targetCassandra)
  .option("writetime", timestamp)
  .mode(SaveMode.Append)
  .save

Verifiera källan och målet

När den historiska databelastningen är klar bör dina databaser vara synkroniserade och redo för en direkt övergång. Vi rekommenderar dock att du verifierar källan och målet för att säkerställa att de matchar innan du slutligen går över.

Nästa steg