สร้างโปรแกรมจำลองระบบคลาวด์ของคุณเอง

หน้านี้จะอธิบายวิธีเรียกใช้ AAOS Emulator เป็นเว็บเซอร์วิสและเรียกใช้ในเว็บเบราว์เซอร์เพื่อให้ผู้ใช้เข้าถึงจากระยะไกลได้ ซึ่งจะเป็นข้อมูลอ้างอิงแบบครบวงจรที่ใช้งานได้จริงขั้นต่ำผ่าน Compute Engine ของ Google Cloud อย่างไรก็ตาม คุณสามารถใช้บริการนี้บนแพลตฟอร์มระบบคลาวด์สาธารณะหรือส่วนตัวใดก็ได้ตามต้องการ

วัตถุประสงค์

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

  • การวิจัยผู้ใช้ การตรวจสอบประสบการณ์ของผู้ใช้ การสนับสนุนลูกค้า และการฝึกอบรม
  • แสดงเดโมต่อผู้มีโอกาสเป็นลูกค้าและในช่องทางการขาย
  • ทดสอบ ตรวจสอบ และแก้ไขข้อบกพร่องของแอป (รวมถึงบิลด์ HMI ของ OEM รายวัน) ได้ในวงกว้าง ลองใช้โปรแกรมจําลองแทนเครื่องทดสอบที่ใช้พัฒนาแอป
  • ตัวแทนของคอลเซ็นเตอร์สำหรับลูกค้าของ OEM มี UI ของ HU ที่เข้าถึงได้ง่ายและเหมือนกัน

ประโยชน์ของการใช้โปรแกรมจำลอง AAOS มีดังนี้

  • ใช้สคริปต์การตั้งค่าเพื่อสร้างโปรแกรมจำลอง AAOS (โปรแกรมจำลองระบบคลาวด์) ที่ปรับแต่งและทำงานบนระบบคลาวด์
  • สร้างอิมเมจ AAOS Cloud Emulator ที่กําหนดเองสําหรับอินสแตนซ์ VM โดยทําดังนี้
    • การตั้งค่าโปรแกรมจำลองแบบระบบคลาวด์ที่พร้อมใช้งาน
    • รูปภาพ AVD ของ AAOS สาธารณะที่พร้อมให้นักสร้างบริการเริ่ม AVD ของ AAOS ด้วยคำสั่ง เช่น รูปภาพ AVD ของ OEM สาธารณะเป็นตัวอย่างให้พาร์ทเนอร์นำไปปรับใช้

สถาปัตยกรรม

สถาปัตยกรรมของตัวอย่างโปรแกรมจำลองระบบคลาวด์แสดงอยู่ด้านล่าง บริการที่ใช้งานได้จริงขั้นต่ำรายการแรกจะทำงานโดยเพิ่มรูปภาพ AVD ของ OEM ของคุณเอง

รูปที่ 1 สถาปัตยกรรม AVD บนระบบคลาวด์

องค์ประกอบพื้นฐานที่สำคัญของโปรแกรมจำลองมีดังนี้

ที่นี่
รายการ วัตถุประสงค์
โปรแกรมจำลอง Android อินสแตนซ์โปรแกรมจำลองโฮสต์อิมเมจ AVD
บริดจ์ Goldfish-webrtc แอป Linux เพื่อให้บริการสื่อสารระหว่างแอป React กับโปรแกรมจำลอง AAOS
android-emulator-webrtc แอป React เพื่อแสดง UI ของโปรแกรมจำลองในเว็บเบราว์เซอร์ React ยังบันทึกเหตุการณ์ที่เป็นอินพุตของผู้ใช้และส่งกลับไปให้เซิร์ฟเวอร์ด้วย
สคริปต์คอนเทนเนอร์โปรแกรมจำลอง Android สคริปต์ Python สำหรับจัดการและสร้างอิมเมจและคอนเทนเนอร์ Docker สําหรับโมดูลซอฟต์แวร์ข้างต้น
สร้างโทเค็นเพื่อจัดการสิทธิ์การเข้าถึงของโปรแกรมจำลอง
เปิดเซิร์ฟเวอร์ สร้างการเชื่อมต่อ WebRTC โดยตรงระหว่างไคลเอ็นต์กับเซิร์ฟเวอร์ คุณต้องเปิดใช้เซิร์ฟเวอร์ก็ต่อเมื่อบริการจําลองทํางานอยู่หลังไฟร์วอลล์หรือพร็อกซีเท่านั้น
Envoy

บริการพร็อกซีสำหรับดำเนินการต่อไปนี้

  • ระบุ HTTPS โดยใช้ใบรับรองที่ลงนามด้วยตนเอง
  • เปลี่ยนเส้นทางการรับส่งข้อมูลในพอร์ต 80 (http) ไปยังพอร์ต 443 (https)
  • ทำหน้าที่เป็นพร็อกซี gRPC สําหรับโปรแกรมจําลอง
  • ยืนยันโทเค็นเพื่ออนุญาตให้เข้าถึงปลายทาง gRPC ของโปรแกรมจำลอง
  • เปลี่ยนเส้นทางคําขออื่นๆ ไปยังคอมโพเนนต์ Nginx ซึ่งโฮสต์แอป React

ตั้งค่าโปรแกรมจำลองใน VM บนระบบคลาวด์

วิธีสร้างโปรเจ็กต์ GCP

  1. ไปที่คอนโซล Google Cloud แล้วเลือกโปรเจ็กต์
  2. หากต้องการยืนยันว่ามีการเปิดใช้การเรียกเก็บเงินสำหรับโปรเจ็กต์ Google Cloud โปรดดูหัวข้อเปิดใช้ ปิดใช้ หรือเปลี่ยนการเรียกเก็บเงินสำหรับโปรเจ็กต์
  3. เปิดใช้ API

สร้าง VM ที่ใช้ Linux ใน GCE

1. เปิดใช้ระบบเสมือนจริงที่ซ้อนกัน

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

  1. ใช้เครื่องมือบรรทัดคำสั่ง gcloud เพื่อยืนยันว่าระบบอนุญาตให้ใช้การจำลองเสมือนที่ซ้อนกัน 
    gcloud beta resource-manager org-policies describe   \
  constraints/compute.disableNestedVirtualization  --effective --project=[PROJECT_ID]

2. สร้างดิสก์บูต Ubuntu-1804-lts

  1. ไปที่ Cloud Console
  2. เลือกโปรเจ็กต์ GCP
  3. ไปที่เมนูการนำทาง แล้วเลือก Compute Engine > ดิสก์ > สร้างดิสก์
    1. ระบุชื่อดิสก์ ตัวอย่างเช่น ubuntu1804lts
    2. เลือกภูมิภาคและโซน หากต้องการรองรับการจำลองเสมือนที่ซ้อนกัน โปรดตรวจสอบว่าภูมิภาคและโซนที่เลือกรองรับโปรเซสเซอร์ Haswell (หรือเวอร์ชันที่ใหม่กว่า) ดูข้อมูลเพิ่มเติมได้ที่หัวข้อภูมิภาคและโซน
    3. เลือกรูปภาพต้นฉบับของ ubuntu-1804-bionic-v20210211
    4. ตั้งค่าขนาดดิสก์ที่เหมาะสม (แนะนำให้ใช้ขนาด 100 GB ขึ้นไป)

รูปที่ 2 สร้างดิสก์สำหรับบูต Ubuntu

3. สร้างอิมเมจที่กำหนดเองด้วยรหัสใบอนุญาตพิเศษเพื่อเปิดใช้ VMX

  1. ไปที่ Cloud Console
  2. เปิด Cloud Shell และใช้คำสั่งต่อไปนี้ 
    gcloud compute images create [IMAGE NAME] --source-disk-zone [DISK ZONE] --source-disk [DISK NAME] \
  --licenses "https://www.googleapis.com/compute/v1/projects/vm-options/global/licenses/enable-vmx"
    • ป้อนชื่อรูปภาพ ตัวอย่างเช่น aaos-emulator-image
    • ตั้งค่าโซนดิสก์เป็นโซนที่คุณสร้างดิสก์
    • ตั้งชื่อดิสก์เป็นชื่อที่คุณใช้สร้างดิสก์

    เช่น

    gcloud compute images create aaos-emulator-image --source-disk-zone us-central1-a \
    --source-disk ubuntu1804lts \
    --licenses \
    "https://www.googleapis.com/compute/v1/projects/vm-options/global/licenses/enable-vmx"

โปรดดูรายละเอียดที่หัวข้ออินสแตนซ์ VM การจำลองเสมือนที่ซ้อนกัน

4. สร้างอินสแตนซ์ VM โดยใช้อิมเมจที่กําหนดเอง

  1. ไปที่ Cloud Console
  2. เลือกโปรเจ็กต์ GCP
  3. ไปที่เมนูการนำทาง > Compute Engine > อินสแตนซ์ VM

    รูปที่ 3 สร้างอินสแตนซ์ VM

  4. ป้อนชื่ออินสแตนซ์ ตัวอย่างเช่น aaosemulator
  5. เลือกตระกูลและประเภทเครื่องที่ต้องการ ตรวจสอบว่าเครื่องมี vCPU 4 ตัวและหน่วยความจำ 16 GB (หรือมากกว่า)
  6. เลือกแพลตฟอร์ม CPU เป็น Intel Cascade Lake (หรือใหม่กว่า)
  7. เปลี่ยนดิสก์สำหรับบูตเป็นอิมเมจที่สร้างในขั้นตอนก่อนหน้า
  8. เปิดใช้ไฟร์วอลล์สำหรับรายการต่อไปนี้
    • อนุญาตการรับส่งข้อมูลจาก HTTP
    • อนุญาตการรับส่งข้อมูลจาก HTTPS

5. กำหนดค่าไฟร์วอลล์ให้เปิดพอร์ต 80 และ 443

  1. ไปที่ Cloud Console
  2. เลือกโปรเจ็กต์ GCP
  3. ไปที่เมนูการนำทาง > Compute Engine > อินสแตนซ์ VM > ตั้งค่ากฎไฟร์วอลล์

ติดตั้งซอฟต์แวร์ที่จำเป็นใน VM

  1. ติดตั้ง Python 3 และ Python3-env โดยทำดังนี้ 
    sudo apt update
sudo apt install python3
sudo apt-get install python3-venv
  2. ติดตั้ง Android SDK และ ADB ที่มีอยู่ในเส้นทาง 
    sudo apt install android-sdk

    หากต้องการติดตั้ง Docker และ Docker-compose โปรดดูDocker และ Docker-compose ตรวจสอบว่าคุณเรียกใช้สิ่งเหล่านี้ได้ในฐานะผู้ใช้ที่ไม่ใช่รูท

  3. วิธียืนยันว่า CPU รองรับการจำลองเสมือนฮาร์ดแวร์ (คำสั่งควรแสดงผลเป็นตัวเลขที่ไม่ใช่ 0) 
    egrep -c '(vmx|svm)' /proc/cpuinfo
  4. ติดตั้ง Kernel Virtual Machine (KVM) หากต้องการติดตั้ง KVM ให้เรียกใช้คำสั่งต่อไปนี้ 
    sudo apt-get install qemu-kvm libvirt-daemon-system libvirt-clients bridge-utils
  5. วิธียืนยันว่า KVM ทํางาน 
    sudo apt install cpu-checker
kvm-ok
    ผลลัพธ์ควรเป็น 
    INFO: /dev/kvm exists
KVM acceleration can be used
  6. วิธีติดตั้ง Node.js และ Node Packet Manager (NPM) 
    sudo apt install nodejs npm

เริ่มคอนเทนเนอร์ที่โฮสต์

  1. หากต้องการยืนยันการติดตั้ง ให้เรียกใช้คอนเทนเนอร์ Android Emulator ที่โฮสต์จากที่เก็บข้อมูลสาธารณะ ดูรายละเอียดเกี่ยวกับคอนเทนเนอร์ได้ที่นี่ ตอนนี้คุณเรียกใช้คอนเทนเนอร์เหล่านี้ได้โดยไม่ต้องสร้าง เช่น 
    docker run \
  -e ADBKEY="$(cat ~/.android/adbkey)" \
  --device /dev/kvm \
  --publish 8554:8554/tcp \
  --publish 5555:5555/tcp  \
  us-docker.pkg.dev/android-emulator-268719/images/30-google-x64:30.1.2

    ซึ่งจะดึงข้อมูลคอนเทนเนอร์ (หากไม่มีในเครื่อง) และเปิดใช้งาน

  2. เมื่อเปิดใช้งานคอนเทนเนอร์แล้ว ให้เชื่อมต่อกับอุปกรณ์โดยกำหนดค่า ADB ในลักษณะเดียวกับการเชื่อมต่อ AVD ในโฮสต์ในเครื่อง เช่น 
    adb connect localhost:5555
adb devices
    ผลลัพธ์ควรเป็น 
    List of devices attached
localhost:5555 device

ตั้งค่าบริการโปรแกรมจำลอง AAOS

วิธีตั้งค่าบริการโปรแกรมจำลอง

  1. ติดตั้งสคริปต์คอนเทนเนอร์ Docker ของโปรแกรมจำลอง Android โดยทำดังนี้ 
    git clone https://github.com/google/android-emulator-container-scripts.git

    cd android-emulator-container-script
source ./configure.sh
  2. ซึ่งจะเปิดใช้งานสภาพแวดล้อมเสมือนและทำให้ emu-docker ที่เรียกใช้ได้พร้อมใช้งาน หากต้องการดูรายละเอียดเกี่ยวกับการใช้งาน ให้เปิดเครื่องมือดังนี้ 
    emu-docker -h
  3. ยอมรับข้อตกลงการอนุญาตให้ใช้สิทธิเพื่อสร้างคอนเทนเนอร์ Docker
  4. สร้างคอนเทนเนอร์ Docker ของโปรแกรมจำลอง AAOS
  5. ดาวน์โหลดบิลด์โปรแกรมจำลองที่ใหม่กว่าเวอร์ชัน 7154743 เช่น 
    sdk-repo-linux-emulator-7154743.zip
  6. ดาวน์โหลดอิมเมจระบบโปรแกรมจำลอง AAOS เช่น sdk-repo-linux-system-images-7115454.zip 
    emu-docker create <emulator-zip> <system-image-zip>
  7. สร้างคอนเทนเนอร์เว็บและตั้งค่าชื่อผู้ใช้และรหัสผ่านสำหรับการเข้าถึงจากระยะไกล 
    ./create_web_container.sh -p user1,passwd1
  8. เริ่มบริการเว็บโปรแกรมจำลอง AAOS โดยทำดังนี้ 
    docker-compose -f js/docker/docker-compose-build.yaml -f js/docker/development.yaml up

คุณเริ่มเว็บเซอร์วิสโปรแกรมจำลอง AAOS เรียบร้อยแล้ว ใช้ข้อมูลต่อไปนี้เพื่อเข้าถึงในเว็บเบราว์เซอร์

https://<VM_External__IP>

การแก้ปัญหา

หากเกิดข้อผิดพลาดในการเชื่อมต่อกับ IP ภายนอกของ VM ให้ตรวจสอบว่าได้ตั้งค่า VM เพื่ออนุญาตทั้งการเข้าชม HTTP และ HTTPS โปรดดูการยืนยันเรื่องนี้ที่หัวข้อการเรียกใช้เว็บเซิร์ฟเวอร์ Apache พื้นฐาน

ตั้งค่าเซิร์ฟเวอร์ Turn

คุณใช้เซิร์ฟเวอร์ Turn ของคุณเองได้ทุกเมื่อ ด้านล่างนี้คือตัวอย่างในอินสแตนซ์ VM ของ Google Cloud

หมายเหตุ: หากต้องการให้เซิร์ฟเวอร์ Turn ทํางานในอินสแตนซ์ VM ของ Google Cloud โปรดกําหนดค่ากฎไฟร์วอลล์ของ VM เพื่ออนุญาตการรับส่งข้อมูลในพอร์ต TCP และ UDP 3478 และ 3479

  1. ติดตั้งเซิร์ฟเวอร์ Coturn 
    sudo apt install coturn
systemctl stop coturn
echo "TURNSERVER_ENABLED=1"|sudo tee -a /etc/default/coturn
  2. แก้ไข /etc/turnserver.conf ด้วยการเพิ่มบรรทัดต่อไปนี้ 
    lt-cred-mech
#set your realm name
realm=test
#coturn username and password
user=test:test123
# external-ip=<VM-Public-IP>/<VM-Private-IP>
external-ip=34.193.52.134/10.128.0.2

systemctl start coturn
  3. แก้ไขไฟล์ YAML ของ Docker Compose ให้รวมการกำหนดค่า TURN โดยทำดังนี้ 
    cd android-emulator-container-script
nano  js/docker/docker-compose-build.yaml
  4. เพิ่มบรรทัดสภาพแวดล้อม 2 บรรทัดต่อไปนี้ในส่วนโปรแกรมจำลอง 
         shm_size: 128M
     expose:
       - "8554"
+    environment:
+       - TURN=printf $SNIPPET
  5. รีสตาร์ทบริการ AAOS Emulator ด้วยการกำหนดค่าการเปลี่ยน อย่าลืมแทนที่ IP ของเซิร์ฟเวอร์ Turn, ชื่อผู้ใช้ และข้อมูลเข้าสู่ระบบด้านล่างด้วยข้อมูลของคุณเอง 
    export SNIPPET="{\"iceServers\":[{\"urls\":\"turn:35.193.52.134:3478\",\"username\":\"test\",\"credential\":\"test123\"}]}"
docker-compose -f js/docker/docker-compose-build.yaml up