การย้ายข้อมูลจาก Compute Engine ไปยัง Kubernetes Engine ด้วย Migrate for Anthos

1. ภาพรวม

การเขียนใหม่หรือการปรับโครงสร้างแอปพลิเคชันที่มีอยู่ให้ทำงานบน Kubernetes อาจทำไม่ได้หรือทำด้วยตนเองไม่ได้เสมอไป Migrate for Anthos ช่วยปรับแอปพลิเคชันที่มีอยู่ให้ทันสมัยและเรียกใช้ใน Kubernetes ได้ ในโค้ดแล็บนี้ คุณจะได้ย้ายข้อมูลเว็บแอปที่มีอยู่ซึ่งโฮสต์ใน Compute Engine ไปยัง Kubernetes Engine โดยใช้ Migrate for Anthos

สิ่งที่คุณจะได้เรียนรู้

วิธีทำให้ Migrate for Anthos ใช้งานได้ในคลัสเตอร์ Kubernetes
วิธีสร้างคอนเทนเนอร์ใน StatefulSet จากอินสแตนซ์ Compute Engine ที่มีอยู่
วิธีทำให้คอนเทนเนอร์ใช้งานได้ใน Kubernetes และกำหนดค่าด้วยตัวจัดสรรภาระงาน

สิ่งที่คุณต้องมี

โปรเจ็กต์ Google Cloud ที่ตั้งค่าการเรียกเก็บเงินแล้ว หากยังไม่มีบัญชีดังกล่าว คุณจะต้องสร้างบัญชี

2. การเริ่มตั้งค่า

คุณสามารถเรียกใช้ Codelab นี้บน Google Cloud Platform ได้อย่างสมบูรณ์โดยไม่ต้องติดตั้งหรือกำหนดค่าในเครื่อง

เปิดใช้ API

ก่อนเริ่มต้น ให้ตรวจสอบว่าได้เปิดใช้ API ที่จำเป็นในโปรเจ็กต์ Google Cloud แล้ว

สร้างเว็บเซิร์ฟเวอร์อินสแตนซ์ Compute

มาสร้างอินสแตนซ์ Compute ที่เราจะใช้โฮสต์เว็บเซิร์ฟเวอร์ nginx เริ่มต้น พร้อมกับกฎไฟร์วอลล์ที่จะช่วยให้เราดูหน้า Landing Page เริ่มต้นของเว็บเซิร์ฟเวอร์ได้ เราทำได้หลายวิธี แต่เพื่อความสะดวกในการใช้งาน เราจะใช้ Cloud Shell

ใน Cloud Shell ให้เรียกใช้คำสั่งต่อไปนี้

gcloud compute instances create webserver --zone=us-central1-a && \
gcloud compute firewall-rules create default-allow-http --allow=tcp:80

ครึ่งแรกของคำสั่งนี้จะสร้างอินสแตนซ์ Google Cloud ในโซน us-central1-a ส่วนครึ่งหลังจะสร้างกฎไฟร์วอลล์ชื่อ "default-allow-http" ซึ่งจะอนุญาตให้การรับส่งข้อมูล http เข้าสู่เครือข่ายของเรา

เมื่อสร้างอินสแตนซ์สำเร็จแล้ว ระบบจะแสดงตารางที่มีรายละเอียดของอินสแตนซ์ จดIP ภายนอกไว้ เราจะต้องใช้ IP นี้เพื่อยืนยันว่าเว็บเซิร์ฟเวอร์ทำงานอยู่ในภายหลัง

เมื่ออินสแตนซ์พร้อมใช้งานแล้ว เราจะใช้ SSH เพื่อเข้าถึงอินสแตนซ์จาก Cloud Shell เพื่อติดตั้ง nginx และเริ่มเว็บเซิร์ฟเวอร์ได้โดยทำดังนี้

gcloud compute ssh --zone us-central1-a webserver

เมื่อเข้าสู่ระบบอินสแตนซ์ Compute แล้ว ให้ติดตั้ง Nginx โดยทำดังนี้

sudo apt install nginx

ออกจากระบบเซสชัน SSH ด้วยคำสั่ง logout

มาตรวจสอบว่าเว็บเซิร์ฟเวอร์ทำงานอยู่โดยป้อน IP ภายนอกของอินสแตนซ์จากก่อนหน้านี้ลงในเบราว์เซอร์ คุณควรเห็นหน้าจอต้อนรับเริ่มต้นของ nginx ดังนี้

เว็บเซิร์ฟเวอร์นี้จะทำหน้าที่เป็นเว็บแอปเดิมที่เราจะย้ายข้อมูลไปยัง Kubernetes โดยใช้ Migrate for Anthos

3. คลัสเตอร์ Kubernetes ที่มี Migrate for Anthos

จากนั้นเราจะสร้างคลัสเตอร์ GKE ซึ่งเป็นที่ที่เราจะย้ายข้อมูลเว็บเซิร์ฟเวอร์ Compute Engine ในท้ายที่สุด ใน Cloud Console ให้เรียกใช้คำสั่งต่อไปนี้

gcloud container clusters create my-gke-cluster \
  --zone us-central1-a \
  --cluster-version 1.13 \
  --machine-type n1-standard-4 \
  --image-type "UBUNTU" \
  --num-nodes 1 \
  --enable-stackdriver-kubernetes

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

จากนั้นไปที่ GCP Marketplace เพื่อทำให้ Migrate for Anthos ใช้งานได้

ในหน้า Marketplace ของ Migrate for Anthos ให้คลิกกำหนดค่า แล้วเลือกโปรเจ็กต์จากรายการหากระบบแจ้ง หน้าถัดไปจะแสดงแบบฟอร์มที่มีค่าเริ่มต้นบางค่าป้อนไว้ ตรวจสอบว่าคลัสเตอร์ที่เลือกคือคลัสเตอร์ที่เราเพิ่งสร้าง แล้วคลิกติดตั้งใช้งาน

ตอนนี้ควรทำให้ Migrate for Anthos ใช้งานได้ในคลัสเตอร์ Kubernetes แล้ว เมื่อการติดตั้งใช้งานเสร็จสิ้น คุณจะเห็นสถานะ "OK" ใน หน้าแอปพลิเคชัน Kubernetes Engine ดังนี้

4. จากอินสแตนซ์ Compute ไปยังชุดการเก็บสถานะ

เรามีคลัสเตอร์ Kubernetes ที่เรียกใช้ Migrate for Anthos แล้ว ตอนนี้เราก็เริ่มกระบวนการย้ายข้อมูลได้ หากต้องการติดตั้งใช้งานอินสแตนซ์การประมวลผลกับคลัสเตอร์ Kubernetes เราจะปิดอินสแตนซ์ Compute Engine เพื่อให้สามารถถ่ายสแนปชอตของดิสก์ได้ ก่อนดำเนินการต่อ โปรดจดรหัสอินสแตนซ์ไว้ ซึ่งเราจะต้องใช้ในภายหลัง

gcloud compute instances describe webserver --zone us-central1-a | grep ^id

มาปิดอินสแตนซ์ Compute กัน

gcloud compute instances stop webserver --zone us-central1-a

ตอนนี้เมื่อหยุดอินสแตนซ์แล้ว เราจะถ่ายภาพรวมดิสก์ได้อย่างปลอดภัยโดยการเรียกใช้สคริปต์ต่อไปนี้ อย่าลืมแทรกรหัสโปรเจ็กต์และรหัสอินสแตนซ์

python3 /google/migrate/anthos/gce-to-gke/clone_vm_disks.py \
  -p <project-id>   -i <instance-id> \
  -z us-central1-a \
  -T us-central1-a \
  -A webserver-statefulset \
  -o containerized-webserver.yaml

โดยclone_vm_disks.py จะทำสิ่งต่อไปนี้เมื่อได้รับรายงาน

ตรวจสอบว่าอินสแตนซ์ GCE ปิดอยู่
สร้างสแนปชอตจากดิสก์ของอินสแตนซ์แต่ละรายการ
สร้างดิสก์ใหม่จากแต่ละสแนปชอต
ลบสแนปชอตที่สร้างขึ้น
สร้างไฟล์ YAML ในไดเรกทอรีการทำงานปัจจุบันเพื่อติดตั้งใช้งาน StatefulSet ที่จะโฮสต์เว็บเซิร์ฟเวอร์

ไฟล์ YAML ที่สร้างขึ้นจะจัดสรรชุด StatefulSet ในคลัสเตอร์ Kubernetes ของเรา พร้อมกับการอ้างสิทธิ์ใน PersistentVolume ที่จำเป็นในการติดตั้งดิสก์ที่คัดลอกไปยังคอนเทนเนอร์เว็บเซิร์ฟเวอร์ของเรา เราสามารถใช้การเปลี่ยนแปลงเหล่านี้ได้โดยkubectl

kubectl apply -f containerized-webserver.yaml

ตรวจสอบสถานะของ webserver-statefulset ในหน้าภาระงาน

การที่สถานะระบุว่า "พ็อดอยู่ระหว่างรอดำเนินการ" เป็นเวลา 2-3 นาทีหลังจากเรียกใช้ kubectl apply ถือเป็นเรื่องปกติ ดำเนินการต่อเมื่อสถานะแสดงเป็น "ตกลง"

5. แสดงคลัสเตอร์ต่อตัวจัดสรรภาระงาน

ตอนนี้คลัสเตอร์ Kubernetes ของเราควรเรียกใช้เว็บเซิร์ฟเวอร์เป็นชุด Stateful แต่เราจะต้องเปิดเผยคอนเทนเนอร์ไปยังตัวจัดสรรภาระงานด้วยเพื่อเข้าถึงเว็บเซิร์ฟเวอร์ผ่านที่อยู่ IP ภายนอก ใน Cloud Shell ให้สร้างไฟล์ใหม่ชื่อ loadbalancer.yaml โดยมีเนื้อหาดังนี้

loadbalancer.yaml

apiVersion: v1
kind: Service
metadata:
  name: webserver-loadbalancer
spec:
  type: LoadBalancer
  selector:
    app: webserver-statefulset
  ports:
  - protocol: TCP
    port: 80
    targetPort: 80

และตอนนี้ให้ใช้กับ kubectl ดังนี้

kubectl apply -f loadbalancer.yaml

เราใช้ kubectl เพื่อดึงข้อมูลที่อยู่ IP ภายนอกของบริการ webserver-container ได้ดังนี้

kubectl get services

หากป้อนที่อยู่ IP ภายนอกในเบราว์เซอร์ เราควรเห็นหน้าจอต้อนรับ nginx เริ่มต้นแบบเดียวกันกับที่เห็นก่อนหน้านี้

เราทำได้แล้ว ตอนนี้เว็บเซิร์ฟเวอร์ GCE ของเราโฮสต์อยู่ใน Kubernetes แล้ว เยี่ยมไปเลย

6. Stackdriver Monitoring

เมตริก

ในฐานะบริการ Kubernetes ที่มีการจัดการ Kubernetes Engine จะได้รับการติดตั้งเครื่องมือโดยอัตโนมัติทั้งสำหรับการบันทึกและการตรวจสอบด้วย Stackdriver มาดูเมตริกบางอย่างที่ Stackdriver บันทึกให้เราโดยอัตโนมัติกัน

คลิกลิงก์การตรวจสอบในเมนูผลิตภัณฑ์ การเข้าถึงลิงก์นี้เป็นครั้งแรกจากโปรเจ็กต์อาจใช้เวลา 2-3 นาทีในขณะที่ระบบตั้งค่าพื้นที่ทำงาน

เมื่อโหลดแล้ว ให้วางเมาส์เหนือทรัพยากรในบานหน้าต่างด้านซ้าย แล้วเลือก "Kubernetes Engine ใหม่" จากเมนู

แต่ละแถวในแดชบอร์ดที่แสดงที่นี่แสดงถึงทรัพยากร Kubernetes คุณสลับระหว่างมุมมองโครงสร้างพื้นฐาน เวิร์กโหลด หรือบริการได้โดยใช้ลิงก์เหนือแดชบอร์ด

ในมุมมองภาระงาน ให้ขยาย "my-gke-cluster" และเจาะลึกลงไปที่ default > webserver-statefulset > webserver-statefulset-0 > webserver-statefulset คลิกที่คอนเทนเนอร์ StatefulSet ของเว็บเซิร์ฟเวอร์ ที่นี่คุณจะเห็นเมตริกสำเร็จรูปบางอย่างที่ Stackdriver บันทึกไว้ ซึ่งรวมถึงการใช้งานหน่วยความจำและการใช้งาน CPU

แผนภูมิที่แสดงในแดชบอร์ดนี้คือแผนภูมิที่เราจะใช้สร้างแดชบอร์ดที่กำหนดเองได้

แดชบอร์ดที่กำหนดเอง

Stackdriver ช่วยให้เราสร้างแดชบอร์ดที่กำหนดเองซึ่งใช้จัดระเบียบแผนภูมิและกราฟสำหรับข้อมูลเมตริกใดก็ได้ที่เรามี มาสร้างแดชบอร์ดที่กำหนดเองเพื่อให้เห็นภาพรวมของเมตริกบางอย่างของเว็บเซิร์ฟเวอร์กัน

ในแผงด้านซ้าย ให้วางเมาส์เหนือแดชบอร์ด แล้วคลิกสร้างแดชบอร์ด

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

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

จากนั้นเราจะกรองตาม project_id (หากมีหลายโปรเจ็กต์) และ container_name ในช่องตัวกรอง ให้พิมพ์ project_id เลือกจากรายการที่กรองแล้ว และเลือกโปรเจ็กต์ในช่องค่า นอกจากนี้ เรายังต้องกรองตาม container_name ด้วย ในช่องตัวกรอง ให้พิมพ์ container_name เลือกจากรายการที่กรองแล้ว และเลือก webserver-statefulset ในช่องค่า คลิกบันทึก

ตอนนี้เรามีแดชบอร์ดที่มีแผนภูมิแรกแล้ว

7. นโยบายการตรวจสอบระยะเวลาทำงานและการแจ้งเตือน

Stackdriver ช่วยให้เราตั้งค่าการแจ้งเตือนเพื่อแจ้งให้เราทราบเมื่อเมตริกใดก็ตามถึงค่าเกณฑ์ที่เรากำหนด เช่น เราสามารถให้ Stackdriver ส่งอีเมลถึงเราเมื่อการใช้ CPU จากขั้นตอนสุดท้ายสูงกว่าเกณฑ์ที่กำหนดเป็นระยะเวลาหนึ่ง ซึ่งอาจบ่งบอกถึงปัญหาเกี่ยวกับแอปของเรา เพื่อแสดงให้เห็นว่าการแจ้งเตือนเหล่านี้มีลักษณะอย่างไร เรามาตั้งค่าการตรวจสอบเวลาทำงาน แล้วจำลองการหยุดทำงานกัน

จากแผงด้านซ้าย ให้เลือกการตรวจสอบระยะเวลาทำงาน แล้วเลือกภาพรวมการตรวจสอบระยะเวลาทำงาน

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

ในแบบฟอร์มที่ดำเนินการต่อ ให้ป้อน "เวลาทำงานของปลายทาง" เป็นชื่อ และที่อยู่ IP ภายนอกของตัวจัดสรรภาระงานเป็นชื่อโฮสต์

คลิกบันทึก แล้วระบบจะแจ้งให้คุณสร้างนโยบายการแจ้งเตือนที่เกี่ยวข้อง

คลิกสร้างนโยบายการแจ้งเตือน

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

เรายังไม่เสร็จ จากนั้นเราจะระบุ Notification Channel เพื่อให้ได้รับการแจ้งเตือนเมื่อมีการละเมิดนโยบายการแจ้งเตือน ในเมนูแบบเลื่อนลงประเภทช่องทางการแจ้งเตือน ให้เลือกอีเมล แล้วตามด้วยอีเมลที่ถูกต้อง

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

หากต้องการดูว่าการแจ้งเตือนจะมีลักษณะอย่างไร ให้เปิด Cloud Shell อีกครั้งใน Cloud Console คำสั่งต่อไปนี้จะหยุดบริการ nginx ที่ทำงานในพ็อดเว็บเซิร์ฟเวอร์ของเรา

kubectl exec -t webserver-statefulset-0 -- /bin/bash -c "nginx -s stop"

หลังจากผ่านไปสักครู่ คุณควรได้รับอีเมลแจ้งเตือนเรื่องการหยุดทำงาน

มาเลิกทำกัน กลับไปที่ Cloud Shell แล้วรีสตาร์ท nginx โดยใช้คำสั่งต่อไปนี้

kubectl exec -t webserver-statefulset-0 -- /bin/bash -c "nginx"

หลังจากนั้นไม่กี่นาที คุณจะได้รับอีเมลอีกฉบับจาก Stackdriver ซึ่งคราวนี้จะมีข่าวดีกว่าเดิม

8. ล้างข้อมูล

ตอนนี้เราได้ย้ายข้อมูลจาก GCE ไปยัง GKE ด้วย Migrate for Anthos แล้ว มาล้างข้อมูลโปรเจ็กต์ของเราจากทรัพยากรทั้งหมดที่เราสร้างขึ้นกัน

ลบโปรเจ็กต์

คุณจะลบทั้งโปรเจ็กต์ก็ได้หากต้องการ ในคอนโซล GCP ให้ไปที่หน้า Cloud Resource Manager

ในรายการโปรเจ็กต์ ให้เลือกโปรเจ็กต์ที่เราใช้ทำงานอยู่ แล้วคลิกลบ ระบบจะแจ้งให้คุณพิมพ์รหัสโปรเจ็กต์ ป้อนรหัสแล้วคลิกปิด

หากต้องการลบคอมโพเนนต์ต่างๆ ทีละรายการ ให้ไปที่ส่วนถัดไป

Stackdriver

หน้าแดชบอร์ด

จากหน้าแดชบอร์ด ให้คลิกไอคอนการตั้งค่า ที่ด้านบนของหน้า แล้วเลือกลบแดชบอร์ด

นโยบายการแจ้งเตือน

จากหน้านโยบาย ให้เลือกลบจากเมนูการดำเนินการ ทางด้านขวาของแต่ละนโยบายที่คุณสร้างขึ้น

การตรวจสอบระยะเวลาทำงาน

จากหน้าการตรวจสอบช่วงเวลาที่ระบบพร้อมใช้งาน ให้เลือกลบจากเมนูการดำเนินการทางด้านขวาของการตรวจสอบแต่ละรายการที่คุณสร้างขึ้น

GCE และ Kubernetes

อินสแตนซ์ Google Compute Engine

gcloud compute instances delete webserver --zone=us-central1-a

คลัสเตอร์ Kubernetes (รวมถึง Migrate for Anthos, StatefulSet และบริการ Load Balancer)

gcloud container clusters delete my-gke-cluster --zone=us-central1-a

ดิสก์

ชุด StatefulSet ของเราใช้ดิสก์ที่เราสร้างขึ้น ใช้ข้อมูลต่อไปนี้เพื่อดึงชื่อ

gcloud compute disks list --filter=webserver

ลบดิสก์โดยใช้ชื่อดิสก์ของคุณแทนชื่อดิสก์ของฉันด้วยคำสั่งต่อไปนี้

gcloud compute disks delete vls-690d-webserver --zone=us-central1-a

ล้างข้อมูลทั้งหมดแล้ว

9. ยินดีด้วย

เยี่ยมไปเลย คุณย้ายข้อมูลเว็บเซิร์ฟเวอร์จากอินสแตนซ์ GCE ไปยังคลัสเตอร์ Kubernetes โดยใช้ Migrate for Anthos

สิ่งที่เราได้พูดถึง

เราย้ายข้อมูลเว็บเซิร์ฟเวอร์จาก GCE ไปยังคลัสเตอร์ Kubernetes โดยใช้ Migrate for Anthos
เราเปิดเว็บเซิร์ฟเวอร์ StatefulSet ให้คนทั่วโลกเข้าถึงได้โดยการแสดงผ่านบริการตัวจัดสรรภาระงานของ Kubernetes
เราเปิดใช้ Stackdriver และสร้างแดชบอร์ดที่กำหนดเอง
เรากำหนดค่าการตรวจสอบระยะเวลาทำงานพร้อมกับนโยบายการแจ้งเตือนเพื่อให้เราทราบเมื่อเว็บเซิร์ฟเวอร์หยุดทำงาน