העברה מ-Cassandra ל-Bigtable באמצעות שרת proxy עם כתיבת כפולה

1. מבוא

‫Bigtable הוא שירות מנוהל של מסד נתונים NoSQL עם רמת ביצועים גבוהה, שמיועד לעומסי עבודה תפעוליים ואנליטיים גדולים. העברה ממסדי נתונים קיימים כמו Apache Cassandra ל-Bigtable לרוב מחייבת תכנון קפדני כדי למזער את זמן ההשבתה ואת ההשפעה על האפליקציה.

ב-Codelab הזה תלמדו על אסטרטגיית מיגרציה מ-Cassandra ל-Bigtable באמצעות שילוב של כלי proxy:

1. ‫Cassandra-Bigtable Proxy: מאפשר ללקוחות ולכלים של Cassandra (כמו cqlsh או דרייברים) ליצור אינטראקציה עם Bigtable באמצעות פרוטוקול Cassandra Query Language ‏ (CQL) על ידי תרגום שאילתות.
2. Datastax Zero Downtime Migration (ZDM) Proxy: פרוקסי בקוד פתוח שמוצב בין האפליקציה לבין שירותי מסד הנתונים (Cassandra המקורי ו-Bigtable של היעד דרך Cassandra-Bigtable Proxy). הוא מתזמן כתיבות כפולות ומנהל את ניתוב התנועה, וכך מאפשר העברה עם שינויים מינימליים באפליקציה וזמן השבתה מינימלי.
3. ‫Cassandra Data Migrator (CDM): כלי בקוד פתוח שמשמש להעברת נתונים היסטוריים בכמות גדולה מאשכול Cassandra של המקור למופע Bigtable של היעד.

מה תלמדו

• איך מגדירים אשכול Cassandra בסיסי ב-Compute Engine.
• איך יוצרים מופע Bigtable.
• איך פורסים ומגדירים את Cassandra-Bigtable Proxy כדי למפות סכימת Cassandra ל-Bigtable.
• איך פורסים ומגדירים את Datastax ZDM Proxy לייצוא לשני יעדים.
• איך משתמשים בכלי Cassandra Data Migrator כדי להעביר נתונים קיימים בכמות גדולה.
• תהליך העבודה הכולל להעברה מ-Cassandra ל-Bigtable באמצעות שרת proxy.

הדרישות

• פרויקט ב-Google Cloud שהחיוב בו מופעל. משתמשים חדשים זכאים לתקופת ניסיון בחינם.
• היכרות בסיסית עם מושגים ב-Google Cloud כמו פרויקטים, Compute Engine, רשתות VPC וכללי חומת אש. היכרות בסיסית עם כלי שורת הפקודה של Linux.
• גישה למכונה שמותקן בה gcloud CLI ומגדירים אותה, או שימוש ב-Google Cloud Shell.

ב-Codelab זה נשתמש בעיקר במכונות וירטואליות (VM) ב-Compute Engine באותה רשת VPC ובאותו אזור, כדי לפשט את הרישות. מומלץ להשתמש בכתובות IP פנימיות.

2. הגדרת הסביבה

1. בוחרים פרויקט קיים או יוצרים פרויקט חדש ב-Google Cloud.

עוברים אל מסוף Google Cloud ובוחרים פרויקט קיים או יוצרים פרויקט חדש. רושמים את מזהה הפרויקט.

2. בחירת אזור ואזור משנה

בוחרים אזור ותחום למשאבים. נשתמש ב-us-central1 וב-us-central1-c כדוגמאות. כדי שיהיה לכם נוח, כדאי להגדיר אותם כמשתני סביבה:

export PROJECT_ID="<your-project-id>"
export REGION="us-central1"
export ZONE="us-central1-c"

gcloud config set project $PROJECT_ID
gcloud config set compute/region $REGION
gcloud config set compute/zone $ZONE

3. הפעלת ממשקי ה-API הנדרשים

מוודאים ש-Compute Engine API ו-Bigtable API מופעלים בפרויקט.

gcloud services enable compute.googleapis.com bigtable.googleapis.com bigtableadmin.googleapis.com

4. הגדרת כללים לחומת אש

אנחנו צריכים לאפשר תקשורת בין מכונות וירטואליות ברשת VPC שמוגדרת כברירת מחדל בכמה יציאות:

• יציאת CQL של Cassandra/Proxies: ‏ 9042
• יציאה לבדיקת תקינות של שרת Proxy של ZDM: ‏ 14001
• SSH: 22

יוצרים כלל חומת אש שמאפשר תנועה פנימית ביציאות האלה. נשתמש בתג cassandra-migration כדי להחיל את הכלל הזה בקלות על מכונות וירטואליות רלוונטיות.

gcloud compute firewall-rules create allow-migration-internal \
--network=default \
--action=ALLOW \
--rules=tcp:22,tcp:9042,tcp:7000,tcp:14001 \
--source-ranges=10.0.0.0/8 \
--target-tags=cassandra-migration

3. פריסת אשכול Cassandra (מקור)

ב-codelab הזה נגדיר אשכול Cassandra פשוט עם צומת יחיד ב-Compute Engine. בתרחיש מהעולם האמיתי, תתחברו לאשכול הקיים שלכם.

1. יצירת מכונה וירטואלית ב-GCE עבור Cassandra

gcloud compute instances create cassandra-origin \
--machine-type=e2-medium \
--image-family=ubuntu-2204-lts \
--image-project=ubuntu-os-cloud \
--tags=cassandra-migration \
--boot-disk-size=20GB \
--scopes=cloud-platform \
--zone="$ZONE"

חיבור SSH למופע של Cassandra

gcloud compute ssh --zone="$ZONE" "cassandra-origin"

2. התקנת Cassandra

# Install Java (Cassandra dependency)
sudo apt-get update
sudo apt-get install -y openjdk-11-jre-headless

# Add Cassandra repository
echo "deb https://debian.cassandra.apache.org 41x main" | sudo tee -a /etc/apt/sources.list.d/cassandra.sources.list
curl https://downloads.apache.org/cassandra/KEYS | sudo apt-key add -

# Install Cassandra
sudo apt update
sudo apt install -y cassandra

# (Optional) Verify Cassandra is running
sudo systemctl status cassandra

3. הגדרת Cassandra

צריך להגדיר את Cassandra כך שאפשר יהיה לגשת אליה ברשת הפרטית.

מריצים את הפקודה הבאה כדי לקבל את כתובת ה-IP הפרטית של cassandra-origin:

hostname -I

עורכים את ההגדרות של Cassandra. לא צריך להוסיף שורות הגדרה חדשות, רק לעדכן את השורות הקיימות:

sudo vim /etc/cassandra/cassandra.yaml

1. הגדרה של seed_provider.parameters.seeds לערך "CASSANDRA_ORIGIN_PRIVATE_IP:7000"
2. הגדרה של rpc_address לערך CASSANDRA_ORIGIN_PRIVATE_IP
3. הגדרה של listen_address לערך CASSANDRA_ORIGIN_PRIVATE_IP

שומרים את הקובץ.

בסיום, מפעילים מחדש את Cassandra כדי לטעון את השינויים בהגדרות:

sudo systemctl restart cassandra

# (Optional) Verify Cassandra is running
sudo systemctl status cassandra

4. יצירת מרחב מפתחות וטבלה

נשתמש בדוגמה של טבלת עובדים וניצור מרחב מפתחות בשם zdmbigtable.

הערה: יכול להיות שיעברו כמה דקות עד ש-Cassandra יתחיל לקבל חיבורים.

# Start cqlsh
cqlsh $(hostname -I)

בתוך cqlsh:

-- Create keyspace (adjust replication for production)
CREATE KEYSPACE zdmbigtable WITH replication = {'class':'SimpleStrategy', 'replication_factor':1};

-- Use the keyspace
USE zdmbigtable;

-- Create the employee table
CREATE TABLE employee (
    name text PRIMARY KEY,
    age bigint,
    code int,
    credited double,
    balance float,
    is_active boolean,
    birth_date timestamp
);

-- Exit cqlsh
EXIT;

משאירים את סשן ה-SSH פתוח או רושמים את כתובת ה-IP של המכונה הווירטואלית (שם המארח -I).

4. הגדרת Bigtable (יעד)

משך 0:01

יוצרים מופע Bigtable. נשתמש ב-zdmbigtable כמזהה המכונה.

gcloud bigtable instances create zdmbigtable \
--display-name="ZDM Bigtable Target" \
--cluster="bigtable-c1" \
--cluster-zone="$ZONE" \
--cluster-num-nodes=1 # Use 1 node for dev/testing; scale as needed

הטבלה ב-Bigtable תיצור בהמשך על ידי סקריפט ההגדרה של Cassandra-Bigtable Proxy.

5. הגדרת שרת Proxy של Cassandra-Bigtable

1. יצירת מכונה וירטואלית ב-Compute Engine ל-Cassandra-Bigtable Proxy

gcloud iam service-accounts create bigtable-proxy-sa \
    --description="Service account for Bigtable Proxy access" \
    --display-name="Bigtable Proxy Access SA"

export BIGTABLE_PROXY_SA_EMAIL=$(gcloud iam service-accounts list --filter="displayName='Bigtable Proxy Access SA'" --format="value(email)")

gcloud bigtable instances add-iam-policy-binding zdmbigtable \
  --member="serviceAccount:$BIGTABLE_PROXY_SA_EMAIL" \
  --role="roles/bigtable.admin"

gcloud compute instances create bigtable-proxy-vm \
--machine-type=e2-medium \
--image-family=ubuntu-2204-lts \
--image-project=ubuntu-os-cloud \
--tags=cassandra-migration \
--boot-disk-size=20GB \
--zone=$ZONE \
--scopes=cloud-platform \
--service-account="$BIGTABLE_PROXY_SA_EMAIL"

מתחברים ב-SSH אל bigtable-proxy-vm:

gcloud compute ssh --zone="$ZONE" "bigtable-proxy-vm"

ב-VM של שרת ה-Proxy של Bigtable, מריצים:

# Install Git and Go
sudo apt-get update
sudo apt-get install -y git

wget https://go.dev/dl/go1.23.6.linux-amd64.tar.gz
sudo rm -rf /usr/local/go
sudo tar -C /usr/local -xzf go1.23.6.linux-amd64.tar.gz

echo 'export GOPATH=$HOME/go' >> ~/.profile
echo 'export PATH=$PATH:/usr/local/go/bin:$GOPATH/bin' >> ~/.profile
source ~/.profile

# Clone the proxy repository
git clone https://github.com/GoogleCloudPlatform/cloud-bigtable-ecosystem.git
cd cloud-bigtable-ecosystem/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/

2. הפעלת Cassandra-Bigtable Proxy

מפעילים את שרת ה-proxy.

# At the root of the cassandra-to-bigtable-proxy directory
go run proxy.go --project-id="$(gcloud config get-value project)" --instance-id=zdmbigtable --keyspace-id=zdmbigtable --rpc-address=$(hostname -I)

הפרוקסי יתחיל להאזין ליציאה 9042 לחיבורי CQL נכנסים. משאירים את סשן הטרמינל הזה פועל. שימו לב לכתובת ה-IP של המכונה הווירטואלית (שם המארח -I)

3. יצירת טבלה באמצעות CQL

מתחברים לכתובת ה-IP של מכונת ה-VM של Cassandra-Bigtable Proxy באמצעות CQLSH. כדי למצוא את כתובת ה-IP, מריצים את הפקודה הבאה באופן מקומי:

gcloud compute instances describe bigtable-proxy-vm --format='get(networkInterfaces[0].networkIP)'

בחלון נפרד, מתחברים באמצעות SSH למכונה הווירטואלית cassandra-origin ומשתמשים ב-cqlsh כדי להתחבר ל-bigtable-proxy. שימו לב שהגדרנו זמן קצוב לתפוגת בקשה ארוך יותר מברירת המחדל, כדי לוודא של-Bigtable יהיה מספיק זמן ליצור את הטבלה הבסיסית. אמור להופיע הכיתוב Connected to cassandra-bigtable-proxy-v0.2.3 או כיתוב דומה, שמציין שהתחברתם ל-proxy של Bigtable ולא לשרת Cassandra המקומי.

# Replace <your-bigtable-proxy-vm-ip> with the ip from the above command
export BIGTABLE_PROXY_IP=<your-bigtable-proxy-vm-ip>
cqlsh --request-timeout=60 $BIGTABLE_PROXY_IP

-- Create the employee table
CREATE TABLE zdmbigtable.employee (
    name text PRIMARY KEY,
    age bigint,
    code int,
    credited double,
    balance float,
    is_active boolean,
    birth_date timestamp
);

ב-CQLSH, מריצים את הפקודה הבאה כדי לוודא שהטבלה נוצרה:

DESC TABLE zdmbigtable.employee;

6. הגדרת שרת ה-Proxy של ZDM

אנחנו ניצור מופע יחיד של ZDM Proxy למעבדה הזו, אבל תרצו להגדיר כמה צמתים להעברה של נתוני ייצור.

1. יצירת מכונת ה-Proxy של ZDM

gcloud compute instances create zdm-proxy-vm \
--machine-type=e2-medium \
--image-family=ubuntu-2204-lts \
--image-project=ubuntu-os-cloud \
--tags=cassandra-migration \
--boot-disk-size=20GB \
--scopes=cloud-platform \
--zone=$ZONE

שימו לב לכתובות ה-IP של שתי המכונות הווירטואליות.

2. הכנת שרת ה-Proxy של ZDM

gcloud compute ssh --zone="$ZONE" zdm-proxy-vm

export ZDM_VERSION="2.3.4"
wget "https://github.com/datastax/zdm-proxy/releases/download/v$ZDM_VERSION/zdm-proxy-linux-amd64-v$ZDM_VERSION.tgz"
tar -xvzf "zdm-proxy-linux-amd64-v$ZDM_VERSION.tgz"

# replace YOUR_ZONE
gcloud config set compute/zone "YOUR_ZONE"
export ZDM_ORIGIN_CONTACT_POINTS=$(gcloud compute instances describe cassandra-origin --format='get(networkInterfaces[0].networkIP)') 
export ZDM_TARGET_CONTACT_POINTS=$(gcloud compute instances describe bigtable-proxy-vm --format='get(networkInterfaces[0].networkIP)')
export ZDM_ORIGIN_USERNAME=""
export ZDM_ORIGIN_PASSWORD=""
export ZDM_TARGET_USERNAME=""
export ZDM_TARGET_PASSWORD=""
export ZDM_PROXY_LISTEN_ADDRESS=0.0.0.0
export ZDM_PROXY_LISTEN_PORT=9042
./zdm-proxy-v${ZDM_VERSION}

7. הגדרת האפליקציה והתחלת כתיבה כפולה

משך 0:05

בשלב הזה בהעברה אמיתית, צריך להגדיר מחדש את האפליקציות כך שיפנו לכתובת ה-IP של מכונת ה-VM של ZDM Proxy (למשל, ‎:9042) במקום להתחבר ישירות ל-Cassandra.

אחרי שהאפליקציה מתחברת ל-ZDM Proxy: קריאות מוגשות מהמקור (Cassandra) כברירת מחדל. פעולות הכתיבה נשלחות גם למקור (Cassandra) וגם ליעד (Bigtable, דרך Cassandra-Bigtable Proxy). כך האפליקציה יכולה להמשיך לפעול כרגיל, ובו-זמנית הנתונים החדשים נכתבים בשני מסדי הנתונים. אפשר לבדוק את החיבור באמצעות cqlsh שמופנה אל ZDM Proxy:

cqlsh $(gcloud compute instances describe zdm-proxy-vm --format='get(networkInterfaces[0].networkIP)')

מנסים להוסיף נתונים:

INSERT INTO zdmbigtable.employee (name, age, is_active) VALUES ('Alice', 30, true); 
INSERT INTO zdmbigtable.employee (name, age, is_active) VALUES ('Anna', 45, true); 
INSERT INTO zdmbigtable.employee (name, age, is_active) VALUES ('Albert', 50, false); 
SELECT * FROM zdmbigtable.employee;

הנתונים האלה צריכים להיכתב גם ב-Cassandra וגם ב-Bigtable. כדי לוודא זאת ב-Bigtable, נכנסים אל מסוף Google Cloud ופותחים את עורך השאילתות של Bigtable עבור המכונה. מריצים שאילתה מסוג SELECT * FROM employee, והנתונים שהוספתם לאחרונה אמורים להופיע.

8. העברת נתונים היסטוריים באמצעות Cassandra Data Migrator

עכשיו, אחרי שהכתיבה הכפולה פעילה לנתונים חדשים, אפשר להשתמש בכלי Cassandra Data Migrator ‏ (CDM) כדי להעתיק את הנתונים ההיסטוריים הקיימים מ-Cassandra אל Bigtable.

1. יצירת מכונה וירטואלית ב-Compute Engine ל-CDM

למכונה הווירטואלית הזו צריך להיות מספיק זיכרון בשביל Spark.

gcloud compute instances create cdm-migrator-vm \
--machine-type=e2-medium \
--image-family=ubuntu-2204-lts \
--image-project=ubuntu-os-cloud \
--tags=cassandra-migration \
--boot-disk-size=40GB \
--scopes=cloud-platform \
--zone=$ZONE

2. התקנת דרישות מוקדמות (Java 11, ‏ Spark)

מתחברים ב-SSH למכונה הווירטואלית cdm-migrator-vm:

gcloud compute ssh cdm-migrator-vm

בתוך ה-VM:

# Install Java 11 
sudo apt-get update 
sudo apt-get install -y openjdk-11-jdk
 
# Verify Java installation 
java -version 

# Download and Extract Spark (Using version 3.5.3 as requested) 
# Check the Apache Spark archives for the correct URL if needed

wget  https://archive.apache.org/dist/spark/spark-3.5.3/spark-3.5.3-bin-hadoop3-scala2.13.tgz
tar -xvzf spark-3.5.3-bin-hadoop3-scala2.13.tgz

echo 'export SPARK_HOME=$PWD/spark-3.5.3-bin-hadoop3-scala2.13' >> ~/.profile
echo 'export PATH=$PATH:$SPARK_HOME/bin' >> ~/.profile
source ~/.profile

3. הורדת Cassandra Data Migrator

בדפדפן, פותחים את הדף CDM Packages ומעתיקים את הקישור ל-‎ .jar מהחלונית Assets. אם גרסה 5.4.0 לא זמינה, בוחרים בגרסה הכי קרובה. מדביקים את הקישור לפקודה שלמטה ומפעילים פתרונות חכמים במכונת ה-VM של כלי ההעברה של CDM, תוך שמירה על המירכאות הבודדות סביב כתובת ה-URL.

wget 'JAR_URL_GOES_HERE' -O cassandra-data-migrator.jar

כדי לוודא שקובץ ה-JAR הורד בצורה תקינה, סורקים אותו באמצעות הכלי jar. אמורה להופיע רשימה ארוכה של קבצים מסוג ‎.class.

jar tf cassandra-data-migrator.jar 

4. הוספת נתונים

אנחנו צריכים להוסיף נתונים להעברה על ידי כתיבה ישירות אל cassandra-origin (ולא אל zdm-proxy-vm)

INSERT INTO zdmbigtable.employee (name, age, is_active) VALUES ('Alfred', 67, true); 
INSERT INTO zdmbigtable.employee (name, age, is_active) VALUES ('Bobby', 12, false); 
INSERT INTO zdmbigtable.employee (name, age, is_active) VALUES ('Carol', 29, true); 

5. הפעלת משימת ההעברה

מריצים את ההעברה באמצעות spark-submit. הפקודה הזו מורה ל-Spark להריץ את קובץ ה-JAR של CDM, באמצעות קובץ המאפיינים שלכם, ומציינת את מרחב המפתחות והטבלה להעברה. משנים את הגדרות הזיכרון (‎–driver-memory, ‎–executor-memory) בהתאם לגודל מכונת ה-VM ולנפח הנתונים.

מוודאים שאתם נמצאים בספרייה שמכילה את קובץ ה-jar של CDM ואת קובץ המאפיינים.

טיפ: כדי לקבל את כתובת ה-IP הפנימית של מכונות ה-VM של Cassandra והפרוקסי, מריצים את הפקודות הבאות מהמחשב המקומי:

gcloud compute instances describe cassandra-origin --format='get(networkInterfaces[0].networkIP)'
gcloud compute instances describe bigtable-proxy-vm --format='get(networkInterfaces[0].networkIP)'

export ORIGIN_HOST="<your-cassandra-origin-ip>"
export TARGET_HOST="<your-bigtable-proxy-vm-ip>"
export KEYSPACE_TABLE="zdmbigtable.employee"
spark-submit --verbose --master "local[*]" \
--driver-memory 3G --executor-memory 3G \
--conf spark.cdm.schema.origin.keyspaceTable="$KEYSPACE_TABLE" \
--conf spark.cdm.connect.origin.host="$ORIGIN_HOST" \
--conf spark.cdm.connect.origin.port=9042 \
--conf spark.cdm.connect.target.host="$TARGET_HOST" \
--conf spark.cdm.connect.target.port=9042 \
--conf spark.cdm.feature.origin.ttl.automatic=false \
--conf spark.cdm.feature.origin.writetime.automatic=false \
--conf spark.cdm.feature.target.ttl.automatic=false \
--conf spark.cdm.feature.target.writetime.automatic=false \
--conf spark.cdm.schema.origin.column.ttl.automatic=false \
--conf spark.cdm.schema.ttlwritetime.calc.useCollections=false \
--class com.datastax.cdm.job.Migrate cassandra-data-migrator.jar

6. אימות העברת הנתונים

אחרי שהעבודה של CDM מסתיימת בהצלחה, צריך לוודא שהנתונים ההיסטוריים קיימים ב-Bigtable.

cqlsh <bigtable-proxy-vm-ip>

בתוך cqlsh:

SELECT COUNT(*) FROM zdmbigtable.employee; -- Check row count matches origin 
SELECT * FROM zdmbigtable.employee LIMIT 10; -- Check some sample data

9. מעבר חד למערכת אחרת (קונספטואלי)

אחרי שמוודאים שהנתונים עקביים בין Cassandra לבין Bigtable, אפשר להמשיך למעבר החד הסופי.

ב-ZDM Proxy, המעבר כולל הגדרה מחדש של הפרוקסי כך שיקרא בעיקר מהיעד (Bigtable) במקום מהמקור (Cassandra). בדרך כלל עושים את זה באמצעות ההגדרה של ZDM Proxy, וכך מעבירים את תנועת הקריאה של האפליקציה ל-Bigtable.

אחרי שמוודאים ש-Bigtable משרת את כל התנועה בצורה תקינה, אפשר לבצע את הפעולות הבאות:

• כדי להפסיק את הייצוא הכפול, צריך להגדיר מחדש את ZDM Proxy.
• להוציא משימוש את אשכול Cassandra המקורי.
• מסירים את ZDM Proxy ומגדירים את האפליקציה להתחבר ישירות ל-Cassandra-Bigtable Proxy או משתמשים ב-Bigtable CQL Client for Java.

הפרטים הספציפיים של הגדרה מחדש של ZDM Proxy לצורך מעבר לא נכללים ב-codelab הבסיסי הזה, אבל הם מפורטים במסמכי Datastax ZDM.

10. הסרת המשאבים

כדי להימנע מחיובים, מוחקים את המשאבים שנוצרו במהלך ה-codelab הזה.

1. מחיקת מכונות וירטואליות ב-Compute Engine

gcloud compute instances delete cassandra-origin zdm-proxy-vm bigtable-proxy-vm cdm-migrator-vm --zone=$ZONE --quiet

2. מחיקת מכונת Bigtable

gcloud bigtable instances delete zdmbigtable

3. מחיקת כללים של חומת אש

gcloud compute firewall-rules delete allow-migration-internal

4. מחיקת מסד נתונים של Cassandra (אם הוא מותקן באופן מקומי או נשמר)

אם התקנתם את Cassandra מחוץ למכונה וירטואלית ב-Compute Engine שנוצרה כאן, צריך לפעול לפי השלבים המתאימים כדי להסיר את הנתונים או להסיר את ההתקנה של Cassandra.

‫11. מעולה!

סיימתם בהצלחה את תהליך ההגדרה של נתיב העברה מבוסס-proxy מ-Apache Cassandra ל-Bigtable.

למדתם איך:

פורסים את Cassandra ואת Bigtable.

• הגדרת שרת ה-proxy של Cassandra-Bigtable לתאימות ל-CQL.
• פורסים את Datastax ZDM Proxy כדי לנהל כתיבה כפולה ותנועה.
• משתמשים בכלי להעברת נתונים של Cassandra כדי להעביר נתונים היסטוריים.

הגישה הזו מאפשרת לבצע העברות עם זמן השבתה מינימלי וללא שינויים בקוד, באמצעות שכבת ה-proxy.

השלבים הבאים

• עיון במסמכי Bigtable
• למידע על הגדרות מתקדמות ועל תהליכי מעבר חד למערכת אחרת (cutover), אפשר לעיין בתיעוד של Datastax ZDM Proxy.
• פרטים נוספים זמינים במאגר של Cassandra-Bigtable Proxy.
• לשימוש מתקדם, אפשר לעיין במאגר Cassandra Data Migrator.
• התנסות ב-Codelabs אחרים של Google Cloud