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

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

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

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

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

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

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

สถาปัตยกรรม

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

รูปที่ 1 สถาปัตยกรรม Cloud AVD

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

ตั้งค่าโปรแกรมจำลองบน Cloud VM

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

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

สร้าง Linux VM ใน GCE

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

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

1. ใช้เครื่องมือบรรทัดคำสั่ง gcloud เพื่อยืนยันว่าอนุญาต Nested Virtualization แล้ว ให้ทำดังนี้

   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. เลือกภูมิภาคและโซน หากต้องการรองรับ Nested Virtualization โปรดตรวจสอบว่าภูมิภาค และโซนที่คุณเลือกรองรับตัวประมวลผล 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
   • ตั้งค่า Disk Zone เป็นโซนที่คุณสร้างดิสก์
   • ตั้งชื่อดิสก์เป็นชื่อที่คุณใช้สร้างดิสก์

   เช่น

   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 รองรับระบบฮาร์ดแวร์เสมือนจริง (คำสั่งควรส่งผล ตัวเลขที่ไม่ใช่ศูนย์):

   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 ที่โฮสต์จากสาธารณะ ที่เก็บได้ ดูรายละเอียดเกี่ยวกับคอนเทนเนอร์ได้ ที่นี่ ตอนนี้คุณสามารถเรียกใช้คอนเทนเนอร์เหล่านี้ได้โดยไม่ต้องสร้าง เช่น

   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 Emulator โดยทำดังนี้

   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 พื้นฐาน

ตั้งค่าเซิร์ฟเวอร์การเลี้ยว

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

หมายเหตุ: หากต้องการให้เซิร์ฟเวอร์การเลี้ยวทำงานบนอินสแตนซ์ 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 ด้วยการกำหนดค่าการเลี้ยว โปรดแทนที่ IP ของเซิร์ฟเวอร์, ชื่อผู้ใช้ และข้อมูลเข้าสู่ระบบด้านล่างด้วย IP ของคุณเอง:

   export SNIPPET="{\"iceServers\":[{\"urls\":\"turn:35.193.52.134:3478\",\"username\":\"test\",\"credential\":\"test123\"}]}"
   docker-compose -f js/docker/docker-compose-build.yaml up