สร้าง Cloud Emulator ของคุณเอง

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

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

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

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

ประโยชน์ของการใช้ AAOS Emulator มีมากมาย:

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

สถาปัตยกรรม

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

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

การสร้างบล็อคจำลองที่สำคัญคือ:

สิ่งของ	วัตถุประสงค์
Android Emulator	อินสแตนซ์อีมูเลเตอร์โฮสต์อิมเมจ AVD
สะพานปลาทอง-webrtc	แอปพลิเคชัน Linux เพื่อให้การสื่อสารระหว่างแอปตอบสนองและ AAOS Emulator
android-emulator-webrtc	ตอบสนอง แอปพลิเคชันเพื่อแสดง Emulator UI ในเว็บเบราว์เซอร์ React ยังจับเหตุการณ์อินพุตของผู้ใช้และส่งกลับไปยังเซิร์ฟเวอร์
สคริปต์คอนเทนเนอร์ Android Emulator	สคริปต์ Python สำหรับจัดการและสร้างอิมเมจ Docker และคอนเทนเนอร์สำหรับโมดูลซอฟต์แวร์ข้างต้น
บริการ JWT (บริการ JSON Web Token)	สร้างโทเค็นเพื่อจัดการสิทธิ์การเข้าถึงของโปรแกรมจำลอง
เปิดเซิร์ฟเวอร์	สร้างการเชื่อมต่อโดยตรงของ WebRTC ระหว่างไคลเอนต์และเซิร์ฟเวอร์ จำเป็นต้องใช้เซิร์ฟเวอร์ Turn เฉพาะเมื่อบริการ Emulator ทำงานอยู่หลังไฟร์วอลล์หรือพร็อกซี
ทูต	บริการพร็อกซี่ไปที่: ระบุ HTTPS โดยใช้ใบรับรองที่ลงนามเอง เปลี่ยนเส้นทางการรับส่งข้อมูลบนพอร์ต 80 (http) ไปยังพอร์ต 443 (https) ทำหน้าที่เป็นพร็อกซี gRPC สำหรับโปรแกรมจำลอง ตรวจสอบโทเค็นเพื่ออนุญาตการเข้าถึงปลายทางจำลอง gRPC เปลี่ยนเส้นทางคำขออื่น ๆ ไปยังองค์ประกอบ Nginx ซึ่งโฮสต์แอปพลิเคชัน React

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

ในการสร้างโปรเจ็กต์ GCP:

1. ไปที่ Google Cloud Console และ เลือกโครงการ
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. ตั้งค่าขนาดดิสก์ที่เหมาะสม (แนะนำให้ใช้ 100GB หรือใหญ่กว่า)

รูปที่ 1. สร้างดิสก์ที่สามารถบู๊ตได้ของ 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"
   

สำหรับรายละเอียด โปรดดู ที่ Nested Virtualization VM Instance

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

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

   

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

4. ป้อนชื่ออินสแตนซ์ ตัวอย่างเช่น aaosemulator
5. เลือกตระกูลเครื่องและประเภทที่ต้องการ ตรวจสอบให้แน่ใจว่าเครื่องมี vCPU สี่ตัวและหน่วยความจำ 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 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 Emulator

ในการตั้งค่าบริการ Emulator:

1. ติดตั้งสคริปต์คอนเทนเนอร์ Android Emulator Docker:

   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. สร้างคอนเทนเนอร์ AAOS Emulator Docker
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 Emulator:

   docker-compose -f js/docker/docker-compose-build.yaml -f js/docker/development.yaml up
   

คุณเริ่มต้น AAOS Emulator Web Service สำเร็จแล้ว! ใช้สิ่งต่อไปนี้เพื่อเข้าถึงบนเว็บเบราว์เซอร์:

https://<VM_External__IP>

การแก้ไขปัญหา

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

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

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

หมายเหตุ: หากต้องการให้เซิร์ฟเวอร์เทิร์นทำงานบนอินสแตนซ์ Google Cloud VM อย่าลืมกำหนดค่ากฎไฟร์วอลล์ 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. แก้ไขไฟล์ Docker Compose YAML เพื่อรวมการกำหนดค่า TURN:

   cd android-emulator-container-script
   nano  js/docker/docker-compose-build.yaml
   

4. เพิ่มบรรทัดสภาพแวดล้อมสองบรรทัดต่อไปนี้ในส่วนโปรแกรมจำลอง:

        shm_size: 128M
        expose:
          - "8554"
   +    environment:
   +       - TURN=printf $SNIPPET
   

5. เริ่มบริการ AAOS Emulator ใหม่ด้วยการกำหนดค่าเทิร์น อย่าลืมเปลี่ยน 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