วิธีการโยกย้ายฐานข้อมูล Dynomite ของคุณไปยัง Redis Enterprise Active-Active Database

ในตอนที่ 1 ของบทความนี้ "ทำไมต้องย้ายฐานข้อมูล Dynomite ไปยัง Redis Enterprise Active-Active Database" เราเปรียบเทียบสถาปัตยกรรมและคุณสมบัติของ Dynomite และ Redis Enterprise เราได้แสดงให้เห็นแล้วว่า Redis Enterprise สามารถช่วยให้คุณกระจาย Redis Enterprise ทางภูมิศาสตร์ด้วยวิธีที่มีคุณลักษณะมากมาย จัดการได้ง่าย และไม่ต้องกังวลกับข้อขัดแย้งระหว่างการเขียนพร้อมกัน

ส่วนที่ II จะอธิบายตัวเลือกการย้ายข้อมูลที่มีให้ย้ายจาก Dynomite ไปยัง Redis Enterprise

โปรดทราบว่าต่อจากนี้ข้อเสนอที่จัดการด้วยตนเองของ Redis Enterprise จะเรียกว่า "ซอฟต์แวร์ Redis Enterprise" และข้อเสนอที่มีการจัดการจะเรียกว่า "การสมัครใช้งาน Redis Enterprise Cloud" หรือ "Cloud"

การย้ายฐานข้อมูล Dynomite ของคุณ

มาปฏิบัติจริงและดูว่าเราสามารถเรียกใช้การย้ายข้อมูลสองประเภทได้อย่างไร:

1. การย้ายข้อมูลโดยใช้คุณลักษณะนำเข้า/ส่งออกของ Redis Enterprise
2. การย้ายข้อมูลโดยใช้คุณลักษณะ ReplicaOf ของ Redis Enterprise หรือที่เรียกว่า Active-Passive

สำหรับวัตถุประสงค์ของภาพประกอบ สมมติว่าเรามีคลัสเตอร์ Dynomite ที่ครอบคลุมศูนย์ข้อมูลสองแห่ง:dc-a และ dc-b ศูนย์ข้อมูลแต่ละแห่งมีหนึ่งชั้นวาง และแต่ละชั้นวางประกอบด้วยสองโหนด ซึ่งระหว่างนั้นชุดข้อมูลจะถูกแจกจ่าย

หากเราจำคำอธิบายสถาปัตยกรรมของ Dynomite ได้ เราก็รู้ว่าชั้นวาง Dynomite แต่ละชั้นมีชุดข้อมูลทั้งหมด

ดังนั้น เราจึงสามารถจำกัดขอบเขตของการย้ายข้อมูลได้ ไม่ว่าจะเป็นการนำเข้า/ส่งออก หรือ Active-Passive ให้เป็นแร็คเดียวภายในการตั้งค่า Dynomite

มาเลือก rack-1-dc-a และสมมติว่า IP ของทั้งสองโหนดมีดังนี้:

• a1:10.0.0.1
• a2:10.0.0.2

เพื่อความชัดเจน นี่คือการกำหนดค่า yaml สำหรับการตั้งค่า Dynomite ของเรา:

#a1
dyn_o_mite:
  datacenter: dc-a
  dyn_listen: 10.0.0.1:7379
  dyn_port: 7379
  dyn_seed_provider: simple_provider
  dyn_seeds:
  - 10.0.0.3:7379:rack1:dc-a:4294967294
  - 10.0.0.4:7379:rack1:dc-b:4294967294
  - 10.0.0.2:7379:rack1:dc-b:2147483647
  listen: 0.0.0.0:8379
  rack: rack1
  servers:
  - 127.0.0.1:6379:1
  timeout: 150000
  tokens: 2147483647
  secure_server_option: datacenter
  pem_key_file: /root/dynomite/conf/dynomite.pem
  data_store: 0
  stats_listen: 127.0.0.1:22222
  read_consistency : DC_QUORUM
  write_consistency : DC_QUORUM

#a2
dyn_o_mite:
  datacenter: dc-a
  dyn_listen: 10.0.0.3:7379
  dyn_port: 7379
  dyn_seed_provider: simple_provider
  dyn_seeds:
  - 10.0.0.1:7379:rack1:dc-a:2147483647
  - 10.0.0.4:7379:rack1:dc-b:4294967294
  - 10.0.0.2:7379:rack1:dc-b:2147483647
  listen: 0.0.0.0:8379
  rack: rack1
  servers:
  - 127.0.0.1:6379:1
  timeout: 150000
  tokens: 4294967294
  secure_server_option: datacenter
  pem_key_file: /root/dynomite/conf/dynomite.pem
  data_store: 0
  stats_listen: 127.0.0.1:22222
  read_consistency : DC_QUORUM
  write_consistency : DC_QUORUM

#b1
dyn_o_mite:
  datacenter: dc-b
  dyn_listen: 10.0.0.2:7379
  dyn_port: 7379
  dyn_seed_provider: simple_provider
  dyn_seeds:
  - 10.0.0.4:7379:rack1:dc-b:4294967294
  - 10.0.0.1:7379:rack1:dc-a:4294967294
  - 10.0.0.3:7379:rack1:dc-a:2147483647
  listen: 0.0.0.0:8379
  rack: rack1
  servers:
  - 127.0.0.1:6379:1
  timeout: 150000
  tokens: 2147483647
  secure_server_option: datacenter
  pem_key_file: /root/dynomite/conf/dynomite.pem
  data_store: 0
  stats_listen: 127.0.0.1:22222
  read_consistency : DC_QUORUM
  write_consistency : DC_QUORUM

#b2
dyn_o_mite:
  datacenter: dc-b
  dyn_listen: 10.0.0.4:7379
  dyn_port: 7379
  dyn_seed_provider: simple_provider
  dyn_seeds:
  - 10.0.0.2:7379:rack1:dc-b:2147483647
  - 10.0.0.1:7379:rack1:dc-a:4294967294
  - 10.0.0.3:7379:rack1:dc-a:2147483647
  listen: 0.0.0.0:8379
  rack: rack1
  servers:
  - 127.0.0.1:6379:1
  timeout: 150000
  tokens: 4294967294
  secure_server_option: datacenter
  pem_key_file: /root/dynomite/conf/dynomite.pem
  data_store: 0
  stats_listen: 127.0.0.1:22222
  read_consistency : DC_QUORUM
  write_consistency : DC_QUORUM

ข้อสังเกตบางประการเกี่ยวกับการกำหนดค่านี้และการตั้งค่าที่ใช้สำหรับการทดสอบบทช่วยสอนนี้:

• GCP VM สี่เครื่องที่ใช้ Ubuntu 18.04
• VM อยู่ใน VPC เดียวกันซึ่งครอบคลุมหลายภูมิภาค
• เปิดพอร์ต 7379 และ 7380 เนื่องจาก Dynomite ใช้พอร์ตเหล่านั้นเพื่อจำลองข้อมูล – “dyn_port” ในการกำหนดค่า yaml
• Redis OSS กำลังทำงานบนแต่ละโหนดบนพอร์ต 6379 – ดู “เซิร์ฟเวอร์” ในการกำหนดค่า yaml
• Dynomite รับฟังคำขอของลูกค้าที่พอร์ต 8379 (เช่น redis-cli -h 10.0.0.1 -p 8379) – ดู "ฟัง" ในการกำหนดค่า yaml

ตอนนี้เราเข้าใจการตั้งค่าของเราแล้วและตัดสินใจว่าจะใช้แร็คใดสำหรับการย้ายข้อมูล มาสร้างฐานข้อมูล Redis Enterprise กัน

สร้างฐานข้อมูล Redis Enterprise Active-Active ของคุณ

เนื่องจากบทความนี้ไม่ได้มีวัตถุประสงค์เพื่ออธิบายวิธีตั้งค่าคลัสเตอร์หรือสร้างฐานข้อมูล โปรดดูเอกสารประกอบด้านล่างเพื่อให้ฐานข้อมูล Active-Active ทำงานได้:

• คลัสเตอร์ซอฟต์แวร์ Redis Enterprise
• การสมัครใช้งานระบบคลาวด์
• การสร้างฐานข้อมูลซอฟต์แวร์
• ซอฟต์แวร์สร้างฐานข้อมูลที่ใช้งานอยู่-ใช้งานอยู่
• การสร้างฐานข้อมูลบนคลาวด์

เพื่อทดสอบสถานการณ์การโยกย้ายทั้งสองของเรา ฉันได้สร้างฐานข้อมูล Active-Active ซึ่งครอบคลุมกลุ่มซอฟต์แวร์ Redis Enterprise Software สองคลัสเตอร์ - หนึ่งแห่งในยุโรปและอีกหนึ่งแห่งในสหรัฐอเมริกา แต่ละคลัสเตอร์ประกอบด้วย VM สามตัวที่รัน Ubuntu 18.04 โปรดทราบว่าหากคุณสร้างฐานข้อมูลโดยไม่มี Active-Active ขั้นตอนการย้ายข้อมูลจะเหมือนเดิม เว้นแต่จะระบุไว้เป็นอย่างอื่นในบทความนี้

มาเริ่มกันเลยกับการย้ายข้อมูลประเภทแรกของเรา

การย้ายข้อมูลโดยใช้คุณสมบัตินำเข้า/ส่งออก

Redis OSS ให้ตัวเลือกการคงอยู่ที่เรียกว่า Redis Database Backup Files หรือ RDB ซึ่งดำเนินการสแนปชอตแบบ point-in-time ของชุดข้อมูลของคุณ ในช่วงเวลาที่กำหนดหรือเมื่อทริกเกอร์โดยคำสั่ง SAVE หรือ BGSAVE

สแน็ปช็อตเหล่านั้นถูกบันทึกในไฟล์ .rdb ซึ่งต่อจากนี้จะเรียกว่าไฟล์ RDB เราจะส่งออกจากเซิร์ฟเวอร์ Dynomite และนำเข้าไปยังฐานข้อมูล Redis Enterprise ของเรา ด้วยวิธีนี้ โปรดทราบว่าการย้ายเดลต้าเป็นไปไม่ได้ และการนำเข้าอาจใช้เวลาสักครู่ ทั้งนี้ขึ้นอยู่กับขนาดของข้อมูล

สำคัญ:ฐานข้อมูลแบบกระจายที่ไม่ใช่ทางภูมิศาสตร์ของ Redis Enterprise กับฐานข้อมูล Active-Active มีความแตกต่างกันมาก:

• ฐานข้อมูลที่ไม่มีการกระจายทางภูมิศาสตร์:เมื่อนำเข้าไฟล์ RDB เนื้อหาฐานข้อมูลที่มีอยู่ทั้งหมดจะถูกลบออก
• ฐานข้อมูล Active-Active:คุณสามารถนำเข้าไฟล์ RDB และรวมเข้ากับชุดข้อมูลที่มีอยู่ของคุณ ซึ่งหมายความว่าคุณสามารถเริ่มส่งการเขียนทราฟฟิกไปยังฐานข้อมูล Active-Active ก่อนและระหว่างการนำเข้า ให้ความสนใจ – หากคุณกำลังเขียนคีย์ไปยังฐานข้อมูล Active-Active ซึ่งมีอยู่แล้วใน Dynomite การนำเข้าที่ตามมาอาจเขียนทับค่าใหม่ด้วยค่าที่เก่ากว่า ! ซึ่งต้องมีการวางแผนอย่างรอบคอบ

วิธีการย้ายข้อมูลจาก Dynomite ไปยัง Redis Enterprise ด้วยไฟล์ RDB มีดังนี้:

• หยุดการรับส่งข้อมูลบนฐานข้อมูล Dynomite และหากคุณได้วางแผนการย้ายข้อมูลอย่างระมัดระวัง และใช้ฐานข้อมูล Active-Active ให้ตัดไปที่ฐานข้อมูล Redis Enterprise
• ส่งออกข้อมูลของแต่ละโหนด (a1 และ a2 ในกรณีของเรา) เป็นไฟล์ RDB
• อัปโหลดไฟล์ RDB ไปยังตำแหน่งที่สามารถเข้าถึงคลัสเตอร์ Redis Enterprise ได้ (เช่น บัคเก็ต Google Cloud Storage, บัคเก็ต AWS S3, เซิร์ฟเวอร์ FTP เป็นต้น)
• นำเข้าไฟล์ RDB ไปยังฐานข้อมูล Redis Enterprise
• ตัดไปที่ฐานข้อมูล Redis Enterprise

มาดูขั้นตอนข้างต้นโดยละเอียดกันดีกว่า

ทางเลือก:แก้ไขไฟล์การกำหนดค่า Redis OSS ในแต่ละโหนด

อินสแตนซ์ Redis OSS ที่ทำงานบนโหนด Dynomite ของคุณจะมีไฟล์การกำหนดค่าตามค่าเริ่มต้นใน /etc/redis หากคุณติดตั้งด้วย "apt-get" หรือในโฟลเดอร์ Redis หากคุณสร้าง Redis OSS ด้วยตัวเอง ไฟล์นี้มีชื่อว่า “redis.conf”

เปิดไฟล์นี้ด้วยโปรแกรมแก้ไขข้อความที่คุณชื่นชอบและค้นหาคำสั่ง "dbfilename" เปลี่ยนชื่อไฟล์ในแต่ละโหนด เช่น 

• “dump1.rdb” บน node1,
• “dump2.rdb” บน node2

เพื่อให้แน่ใจว่าเมื่อเราส่งออกไฟล์ RDB ไปยังที่จัดเก็บข้อมูลภายนอก จะไม่มีชื่อเดียวกัน คุณสามารถข้ามขั้นตอนนี้และเปลี่ยนชื่อหลังจากถ่ายภาพได้หากต้องการ

นอกจากนี้ คุณยังสามารถ:

• เปลี่ยนไดเร็กทอรีที่จะเก็บไฟล์ RDB ด้วยคำสั่ง "dir"
• เปลี่ยนช่วงเวลาการสแนปชอตหรือปิดใช้งานการบันทึกสแนปชอตอัตโนมัติ ในบทช่วยสอนนี้ เราจะใช้คำสั่ง SAVE Redis เพื่อทริกเกอร์การทำสแนปชอต เพื่อให้แน่ใจว่าจะดัมพ์ชุดข้อมูลทั้งหมดเมื่อเราหยุดการรับส่งข้อมูลแล้ว

โปรดทราบว่าหลังจากแก้ไขไฟล์การกำหนดค่า Redis OSS คุณต้องรีสตาร์ทเซิร์ฟเวอร์ Redis OSS เพื่อให้พิจารณาการเปลี่ยนแปลงของคุณ

ดัมพ์ข้อมูล

ตอนนี้หยุดการรับส่งข้อมูลที่เข้ามาในฐานข้อมูล Dynomite ของคุณผ่านพอร์ต 8379 อีกครั้ง หากคุณกำลังนำเข้าฐานข้อมูล Active-Active และวางแผนการย้ายข้อมูลของคุณอย่างระมัดระวัง เพื่อไม่ให้เกิดความเสี่ยงในการเขียนทับโดยไม่ได้ตั้งใจในระหว่างการนำเข้า คุณสามารถตัดการรับส่งข้อมูลไปที่ ฐานข้อมูล Active-Active ของคุณ

เปิดตัว redis-cli อย่าใช้พอร์ต 8379 พอร์ตการฟังของ Dynomite ให้ใช้พอร์ต 6379 แทน เนื่องจากเราต้องเชื่อมต่อกับอินสแตนซ์ Redis OSS ที่ทำงานบนโหนดของเรา ไม่ใช่กับคลัสเตอร์ Dynomite ซึ่งไม่รองรับคำสั่ง SAVE คุณสามารถเรียกใช้ redis-cli โดยไม่ต้องมีอาร์กิวเมนต์บรรทัดคำสั่ง

ในแต่ละโหนด ให้รันคำสั่ง DBSIZE คุณจะได้รับจำนวนคีย์ที่จัดเก็บไว้ในแต่ละอินสแตนซ์ของ Redis OSS จำนวนรวมควรเป็นจำนวนคีย์ในฐานข้อมูล Dynomite ของเรา

#a1
127.0.0.1:6379> dbsize
(integer) 1323

#a2
127.0.0.1:6379> dbsize
(integer) 1371

รันคำสั่ง SAVE และตรวจสอบว่าไฟล์ RDB ของคุณถูกสร้างขึ้นใน /var/lib/redis – หรือไดเร็กทอรีที่คุณระบุไว้

ส่งออกไฟล์ดัมพ์สองไฟล์ไปยังที่จัดเก็บข้อมูลภายนอก

ตอนนี้เราพร้อมที่จะส่งออกไฟล์ RDB สองไฟล์ไปยังที่จัดเก็บข้อมูลภายนอกแล้ว

สำหรับบทช่วยสอนนี้ ฉันจะส่งออกไฟล์ไปยัง Cloud Storage ของ Google Cloud แต่คุณยังสามารถใช้ตัวเลือกการจัดเก็บข้อมูลภายนอกอื่นๆ เช่น FTP Server, โซลูชันพื้นที่เก็บข้อมูล Cloud Service Provider อื่น หรือดิสก์ภายนอกที่สามารถเข้าถึงได้จากคลัสเตอร์ Redis Enterprise ของคุณ คุณสามารถค้นหาข้อมูลเพิ่มเติมเกี่ยวกับตัวเลือกเหล่านี้ได้ที่ด้านล่าง:

• ซอฟต์แวร์ Redis Enterprise
• Redis Enterprise Cloud

ใน Google Cloud ฉันได้สร้างสิ่งต่อไปนี้:

• บัญชีบริการที่ฉันได้สร้างคีย์ JSON
• ที่เก็บข้อมูลบนคลาวด์ที่ฉันให้สิทธิ์ Storage Legacy Object Reader แก่บัญชีบริการของฉัน

ตอนนี้สำหรับแต่ละโหนด เราจะเรียกใช้คำสั่งต่อไปนี้:

gsutil cp path_to_dump_file gs://your_bucket

ตอนนี้เราเห็นไฟล์ RDB สองไฟล์ในบัคเก็ต Google Cloud แล้ว:

ตอนนี้เราพร้อมที่จะนำเข้าไปยังฐานข้อมูล Active-Active ของเราแล้ว

นำเข้าไฟล์ดัมพ์ไปยังฐานข้อมูล Redis Enterprise

เข้าสู่ระบบ Redis Enterprise UI และเลือกฐานข้อมูล Active-Active ของคุณ เช่นเดียวกับในบทช่วยสอนนี้ คุณได้สร้างฐานข้อมูล Redis Enterprise Active-Active ที่ครอบคลุมหลายคลัสเตอร์ คุณสามารถเชื่อมต่อกับ UI ผ่านคลัสเตอร์ใดก็ได้ที่คุณต้องการ ในบทแนะนำนี้ เราจะใช้คลัสเตอร์ยุโรป (EU)

หากคุณกำลังใช้ฐานข้อมูล Cloud Active-Active เพียงเชื่อมต่อกับ Cloud UI และเลือกฐานข้อมูลของคุณ

ไปที่หน้าการกำหนดค่าฐานข้อมูลของเราแล้วคลิกปุ่มนำเข้า เลือกประเภทการจัดเก็บที่เหมาะสม ในกรณีของเรา นี่จะเป็น Google Cloud Storage

ตอนนี้ เราสามารถเพิ่มเส้นทาง Cloud Storage ของไฟล์ RDB สองไฟล์ของเราได้แล้ว เช่น:

• /helene-test/dump1.rdb
• /helene-test/dump2.rdb

เราจำเป็นต้องเพิ่มข้อมูลต่อไปนี้ด้วย:

• รหัสลูกค้า
• อีเมลลูกค้า
• รหัสคีย์ส่วนตัว
• คีย์ส่วนตัว

ข้อมูลนี้อยู่ในไฟล์คีย์ JSON ที่คุณดาวน์โหลดเมื่อสร้างคีย์สำหรับบัญชีบริการ Google Cloud

โปรดทราบว่าคีย์ส่วนตัวมีรูปแบบแปลก ๆ ในไฟล์ JSON; มีเครื่องหมายคำพูดและขึ้นบรรทัดใหม่ หากต้องการจัดรูปแบบอย่างรวดเร็วในลักษณะที่ Redis Enterprise UI จะยอมรับ เพียงแค่เปิดล่ามไพธอนแล้วพิมพ์:

print(WHOLE_COPIED_KEY)

ขณะนี้เรามีการกำหนดค่าการนำเข้าดังต่อไปนี้:

คลิกนำเข้าและรอให้การนำเข้าเสร็จสิ้นซึ่งจะขึ้นอยู่กับขนาดของฐานข้อมูล

ตรวจสอบฐานข้อมูลและตัดต่อ

ด้วย redis-cli ให้เชื่อมต่อกับปลายทางของฐานข้อมูล Redis Enterprise ของคุณ ลองอ่านคีย์บางคีย์และเรียกใช้คำสั่ง DBSIZE เพื่อตรวจสอบว่าคุณมีจำนวนคีย์ที่ถูกต้องหรือไม่

redis-12000.internal.helene-eu-cluster.demo.redislabs.com:12000> dbsize
(integer) 2694

อย่าลืมตรวจสอบ Active-Active Geo-Duplication ด้วย! เพียงเชื่อมต่อกับปลายทางฐานข้อมูลของคลัสเตอร์อื่น ในกรณีของเรา ที่นี่ ในสหรัฐอเมริกา และตรวจสอบจำนวนคีย์ที่คุณได้รับ

การโยกย้ายของคุณสิ้นสุดลงแล้ว คุณสามารถตัดการรับส่งข้อมูลไปยังฐานข้อมูลของคุณได้หากยังไม่ได้ดำเนินการ

การย้ายข้อมูลโดยใช้คุณลักษณะ ReplicaOf

มาทำการย้ายข้อมูลแบบต่อเนื่องกัน

ฟีเจอร์ Redis Enterprise 'ReplicaOf' (เรียกอีกอย่างว่า Active-Passive ใน Redis Cloud UI) ช่วยให้เราจำลองข้อมูลระหว่างฐานข้อมูล Redis สองฐานข้อมูลได้อย่างต่อเนื่อง ข้อได้เปรียบหลักคือการจำลองเดลต้าหลังจากการซิงโครไนซ์ครั้งแรกเสร็จสิ้น ซึ่งหมายความว่าแทบไม่มีการหยุดทำงานด้านแอปพลิเคชันที่สังเกตพบ

ขั้นตอนคือ:

• สร้างลิงก์ ReplicaOf ระหว่างฐานข้อมูล Dynomite และฐานข้อมูล Active-Active
• รอจนกว่าการซิงโครไนซ์เริ่มต้นจะเสร็จสิ้น
• หยุดการจราจรบนฐานข้อมูล Dynomite
• รอจนกว่าเดลต้าจะถูกจำลองแบบอีกครั้ง
• ลบลิงค์ ReplicaOf ระหว่างฐานข้อมูล
• ตัดไปยังฐานข้อมูล Active-Active

ReplicaOf มีวัตถุประสงค์เพื่อใช้ในลักษณะ Active-Passive ซึ่งหมายความว่าเป้าหมายจะถือว่าเป็นแบบพาสซีฟ และจำเป็นต้องยอมรับเพื่อให้เป้าหมายได้รับการซิงโครไนซ์ใหม่อย่างสมบูรณ์ (ล้างฐานข้อมูลเป้าหมาย + ซิงค์จากฐานข้อมูลต้นทาง)

ก่อนเริ่มการย้ายข้อมูล เรามาพูดถึงประเด็นด้านความปลอดภัยกันก่อน

การกำหนดค่าความปลอดภัยสำหรับ Redis OSS ในการตั้งค่า Dynomite

ก่อนอื่น คุณต้องเพิ่มกฎขาเข้าสำหรับ TCP แบบกำหนดเองที่มีพอร์ต 6379 สำหรับเครือข่ายที่แร็ค Dynomite ของคุณใช้งานอยู่

ประการที่สอง จำเป็นต้องอัปเดตไฟล์การกำหนดค่า Redis OSS บนโหนด Dynomite ทั้งสองโหนด ตามค่าเริ่มต้น Redis จะรับฟังเฉพาะที่อยู่อินเทอร์เฟซแบบวนรอบ IPv4 และ IPv6 (ถ้ามี) ซึ่งหมายความว่า Redis OSS จะสามารถยอมรับการเชื่อมต่อไคลเอ็นต์จากโฮสต์เดียวกันกับที่เปิดใช้งานอยู่เท่านั้น เราจำเป็นต้องอัปเดตคำสั่ง "ผูก" ของ Redis OSS เพื่อให้ Redis OSS สามารถรับฟังการเชื่อมต่อจากโฮสต์คลัสเตอร์ Redis Enterprise ของเราได้

มีสองวิธีในการทำเช่นนี้:

• ให้ Redis OSS ฟังเฉพาะการเชื่อมต่อที่มาจากเครื่องใน VPC แบบเพียร์ – ที่แนะนำและปลอดภัยยิ่งขึ้น
• อนุญาตให้โฮสต์ทั้งหมดเข้าถึง Redis OSS – ไม่ปลอดภัย โดยเฉพาะอย่างยิ่งเนื่องจาก Dynomite ไม่รองรับรหัสผ่านฐานข้อมูล

มาพูดถึงสองตัวเลือกนี้โดยละเอียดกัน

ตัวเลือกที่ 1 – ด้วยการเพียร์ VPC

ตัวเลือกแรกคือเพียร์ VPC ที่แร็ค Dynomite ของคุณใช้งานกับ VPC ที่คลัสเตอร์ Redis Enterprise ของคุณใช้งานอยู่ โปรดทราบว่า ถ้าคุณได้สร้างฐานข้อมูล Active-Active ขึ้นมา เช่นเดียวกับเรา ฐานข้อมูลนั้นจะอยู่ในคลัสเตอร์ใดก็ได้ เช่นเคย เราจะใช้คลัสเตอร์ยุโรป (EU) สำหรับการสาธิต

เมื่อคุณเพียร์เครือข่ายของคุณแล้ว คุณเพียงแค่ต้องแก้ไขคำสั่ง "bind" ในไฟล์ redis.conf:เพิ่ม IP ส่วนตัวของเครื่อง Dynomite ของคุณหลังจากที่อยู่อินเทอร์เฟซลูปแบ็คเริ่มต้น

ทำเช่นนี้กับโหนดทั้งหมดในแร็ค เท่านี้ก็เรียบร้อย! อย่าลืมรีสตาร์ทอินสแตนซ์ Redis OSS ของคุณ

ตัวเลือก 2 – ไม่มีการเพียร์ VPC

หากคุณไม่สามารถหรือไม่ต้องการเพียร์เครือข่ายของคุณ คุณต้องอัปเดตไฟล์การกำหนดค่า Redis OSS ในแต่ละโหนดด้วยวิธีต่อไปนี้:

• แสดงความคิดเห็นเกี่ยวกับคำสั่ง "ผูก" ซึ่งจะเปิดเผยอินสแตนซ์ Redis OSS ของคุณแก่ทุกคนบนอินเทอร์เน็ต
• ตั้งค่า “protected-mode” เป็น “no” เพื่อให้ไคลเอ็นต์จากโฮสต์อื่นสามารถเชื่อมต่อกับ Redis ได้ แม้ว่าจะไม่ได้กำหนดค่าการตรวจสอบสิทธิ์ และไม่มีการแสดงชุดอินเทอร์เฟซเฉพาะอย่างชัดเจนโดยใช้คำสั่ง “bind”

สิ่งสำคัญ: จำเป็นต้องมีขั้นตอนสุดท้ายนี้เนื่องจาก Dynomite ไม่รองรับคำสั่ง OSS AUTH ของ Redis ซึ่งทำให้เราไม่สามารถตั้งรหัสผ่านฐานข้อมูลได้ ดังนั้น หากคุณไม่ได้ใช้ไฟร์วอลล์เพื่อควบคุมว่าใครเชื่อมต่อกับพอร์ตที่ใช้งาน ใครก็ได้ สามารถเชื่อมต่อกับอินสแตนซ์ Redis OSS และเข้าถึง/เปลี่ยนแปลง/ลบข้อมูลได้ เปิดพอร์ต 6379 ไปยังโฮสต์ของคลัสเตอร์ Redis Enterprise เท่านั้น

หากคุณต้องการใช้รหัสผ่านจริงๆ คุณสามารถทำได้ แต่จะทำให้ไม่สามารถเรียกใช้การย้ายข้อมูลแบบต่อเนื่องได้ เนื่องจากคุณต้องดำเนินการดังต่อไปนี้:

• หยุดการรับส่งข้อมูลไปยังฐานข้อมูล Dynomite
• แก้ไขคำสั่ง “requirepass” เพื่อตั้งรหัสผ่านสำหรับฐานข้อมูล จากจุดนี้ไป คุณจะไม่สามารถส่งทราฟฟิกการเขียนใดๆ ไปยังฐานข้อมูล Dynomite ของคุณโดยใช้พอร์ต 8379 ได้ เนื่องจากต้องใช้คำสั่ง AUTH เพื่อเข้าถึงฐานข้อมูล
• ดำเนินการย้ายข้อมูลโดยใช้ ReplicaOf ตามที่อธิบายไว้ด้านล่าง
• ตัดการรับส่งข้อมูลไปยังฐานข้อมูล Redis Enterprise

การพิจารณาด้านความปลอดภัยอีกครั้ง และเราพร้อมที่จะเริ่มการย้ายข้อมูลแล้ว!

ไม่บังคับ – เปิดใช้งาน TLS

เพื่อป้องกันการเข้าถึงข้อมูลของคุณโดยไม่ได้รับอนุญาต Redis Enterprise รองรับโปรโตคอล TLS

หากคุณกำลังใช้ซอฟต์แวร์ Redis Enterprise คุณสามารถกำหนดค่าสำหรับการสื่อสาร ReplicaOf ได้โดยเฉพาะ หากคุณใช้ Redis Enterprise Cloud คุณสามารถเปิดใช้งาน TLS โดยทั่วไปได้

ตั้งค่าการเชื่อมโยง ReplicaOf ระหว่างฐานข้อมูล

ใน Redis Enterprise UI ให้ไปที่หน้าการกำหนดค่าฐานข้อมูล Active-Active แล้วคลิกแก้ไข

เรามีตัวเลือกในการเปิดใช้งาน Active-Passive/ReplicaOf เมื่อเสร็จแล้ว เราสามารถเพิ่มแหล่งที่มาในรูปแบบต่อไปนี้ :

redis://:@IP:port

โปรดทราบ:

• ReplicaOf อนุญาตแหล่งที่มาสูงสุด 32 แหล่ง ซึ่งหมายความว่าหากคุณแจกจ่ายชุดข้อมูลของคุณไปยังโหนดมากกว่า 32 โหนดในชั้นวาง Dynomite คุณจะใช้ตัวเลือกนี้ไม่ได้
• หากคุณเคยใช้ VPC Peering คุณควรใช้ IP ส่วนตัวของเครื่องของคุณ
• หากคุณไม่ได้ใช้การเพียร์ VPC:
  • คุณควรใช้ IP สาธารณะของเครื่องของคุณ
  • หากคุณตัดสินใจตั้งรหัสผ่านให้กับฐานข้อมูลของคุณ (และเรียกใช้การย้ายข้อมูลแบบครั้งเดียว) รหัสผ่านควรระบุดังนี้:redis://:password@IP:port

ในกรณีของเรา เมื่อใช้ VPC Peering นี่คือแหล่งที่มาของเรา:

เริ่มการย้ายข้อมูล

ตอนนี้ มาทำตามขั้นตอนต่อไปนี้:

• คลิกอัปเดตใน Redis Enterprise UI
• รอให้การซิงโครไนซ์เริ่มต้นสิ้นสุดลง
• หยุดการรับส่งข้อมูลไปยังฐานข้อมูล Dynomite
• รอให้เดลต้าซิงโครไนซ์
• อัปเดตฐานข้อมูล Active-Active อีกครั้งเพื่อปิดใช้งาน ReplicaOf
• เริ่มการรับส่งข้อมูลบนฐานข้อมูล Active-Active

ตรวจสอบข้อมูลของคุณ

เช่นเคย เชื่อมต่อกับฐานข้อมูลของคุณด้วย redis-cli และตรวจสอบว่าข้อมูลของคุณได้รับการโยกย้ายแล้ว ตรวจสอบ Active-Active Geo-Duplication ด้วยเช่นกันโดยเชื่อมต่อกับคลัสเตอร์อื่น/จุดสิ้นสุดในเครื่องอื่นๆ

บทสรุป

Redis ได้รับการเสนอชื่อให้เป็นฐานข้อมูลที่นักพัฒนาชื่นชอบมากที่สุดมาหลายปี หากคุณกำลังใช้ Dynomite อาจเป็นเพราะคุณรัก Redis เช่นกัน ที่ Redis ซึ่งเป็นบ้านของทั้ง Redis OSS และ Redis Enterprise เราสามารถช่วยให้องค์กรของคุณกระจาย Redis ทางภูมิศาสตร์ด้วยวิธีที่จัดการได้มากขึ้น ในขณะที่รักษามาตรฐานทางวิชาการสูงสุดสำหรับการแก้ไขข้อขัดแย้ง