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

1. מבוא

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

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

1. ‫Cassandra-Bigtable Proxy: מאפשר ללקוחות ולכלים של Cassandra (כמו cqlsh או דרייברים) ליצור אינטראקציה עם Bigtable באמצעות פרוטוקול Cassandra Query Language ‏ (CQL) על ידי תרגום שאילתות.
2. Datastax Zero Downtime Migration (ZDM) Proxy: שרת 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.

בסדנת התכנות הזו נשתמש בעיקר במכונות וירטואליות (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"

התחברות למופע Cassandra באמצעות SSH

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. הגדרת Cassandra-Bigtable Proxy

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. הגדרת ZDM Proxy

אנחנו ניצור מופע יחיד של 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 Console ופותחים את עורך השאילתות של 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 ומעתיקים את הקישור ל-‎ .jar מהחלונית Assets. אם גרסה 5.4.0 לא זמינה, בוחרים את הגרסה הכי קרובה. מדביקים את הקישור לפקודה הבאה ומריצים אותה במופע cdm-migrator-vm, תוך שמירה על המירכאות הבודדות סביב כתובת ה-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 Data Migrator כדי להעביר נתונים היסטוריים.

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

השלבים הבאים

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