Utwórz własny emulator chmury

Z tej strony dowiesz się, jak uruchomić emulację AAOS jako usługę internetową i uruchomić ją w przeglądarce, aby była dostępna dla użytkowników zdalnie. Dzięki temu uzyskasz kompleksowe, minimalnie możliwe do wdrożenia rozwiązanie w Google Cloud Compute Engine. Możesz jednak korzystać z tej usługi na dowolnej wybranej przez siebie platformie publicznej lub prywatnej chmury.

Cel

Ta scentralizowana konfiguracja i ustawienie sprawiają, że emulator AAOS jest dostępny dla całej firmy, dostawców i programistów pracujących z domu. Dzięki temu można efektywniej zarządzać emulatorem AAOS i aktualizować go do nowych wersji, a także zaoszczędzić czas potrzebny na konfigurowanie maszyn lokalnych i zarządzanie nimi przez poszczególnych użytkowników. To rozwiązanie optymalizuje wykorzystanie zasobów sprzętowych i umożliwia tworzenie aplikacji w środowisku o niższych kosztach. Na przykład w celu:

  • Badania użytkowników, przeglądanie doświadczeń użytkowników, obsługa klienta i szkolenia.
  • prezentacje dla potencjalnych klientów i w kanałach sprzedaży;
  • testować, sprawdzać i nawet debugować aplikacje (w tym codzienne kompilacje HMI OEM) na dużą skalę. Rozważ użycie emulatora zamiast testów wykonywanych na stanowiskach testowych.
  • Pracownicy obsługi klienta OEM w centrum obsługi klienta mają jednolity, łatwy w użyciu interfejs HU.

Emulator AAOS ma wiele zalet:

  • Użyj skryptu konfiguracyjnego, aby utworzyć dostosowany emulator AAOS w chmurze (emulator w chmurze).
  • Utwórz niestandardowy obraz AAOS Cloud Emulator dla instancji maszyn wirtualnych:
    • gotowa konfiguracja emulatora działającego w chmurze.
    • Publiczne obrazy AAOS AVD dostępne dla twórcy usługi, aby uruchomić AAOS AVD za pomocą polecenia. Na przykład publiczne obrazy AVD OEM jako przykłady, które partnerzy mogą dostosować i zastosować.

Architektura

Poniżej przedstawiono architekturę przykładowego emulatora chmury. Pierwsza minimalnie wystarczająca usługa będzie działać po dodaniu własnych obrazów OEM AVD.

Rysunek 1. Architektura AVD w chmurze.

Główne elementy składowe emulatora to:

tutaj.
Produkt Cel
Emulator Androida Instancja emulatora hostuje obrazy AVD
Most Goldfish-WebRTC Aplikacja na Linuksa umożliwiająca komunikację między aplikacją React a emulatorem AAOS
android-emulator-webrtc Aplikacja React, aby wyświetlić interfejs emulatora w przeglądarce. React rejestruje też zdarzenia wejściowe użytkownika i wysyła je z powrotem na serwer.
Skrypty kontenera emulatora Androida skrypty Pythona do zarządzania obrazami i kontenerami Dockera oraz tworzenia ich dla powyższych modułów oprogramowania;
Generuje tokeny do zarządzania uprawnieniami dostępu emulatora.
Włączanie serwera Ustawia bezpośrednie połączenie WebRTC między klientem a serwerem. Włączanie serwera jest wymagane tylko wtedy, gdy usługa emulatora działa za zaporami ogniowymi lub serwerami proxy.
Envoy

usługa pośrednicząca:

  • Udostępniaj HTTPS przy użyciu samodzielnie podpisanego certyfikatu.
  • Przekierowuj ruch przez port 80 (http) na port 443 (https).
  • działać jako serwer proxy gRPC dla emulatora.
  • Potwierdź tokeny, aby uzyskać dostęp do punktu końcowego gRPC emulatora.
  • przekierowywać inne żądania do komponentu Nginx, który hostuje aplikację React.

Konfigurowanie emulatora w maszynie wirtualnej w chmurze

Aby utworzyć projekt GCP:

  1. Otwórz konsolę Google Cloud i wybierz projekt.
  2. Aby sprawdzić, czy w projekcie Google Cloud włączone są płatności, zapoznaj się z artykułem Włączanie, wyłączanie i zmienianie rozliczeń w projekcie .
  3. Włącz interfejs API.

Tworzenie maszyny wirtualnej z systemem Linux w GCE

1. Włączanie zagnieżdżonej wirtualizacji

Domyślnie zhierarchizowana wirtualizacja jest dozwolona na poziomie projektu, folderu lub organizacji. Jeśli ktoś z Twojej organizacji nie wyłączył zduplikowanej wirtualizacji, nie musisz nic robić, aby ją włączyć.

  1. Aby sprawdzić, czy dozwolona jest wirtualizacja zagnieżdżona, użyj narzędzia wiersza poleceń gcloud: 
    gcloud beta resource-manager org-policies describe   \
  constraints/compute.disableNestedVirtualization  --effective --project=[PROJECT_ID]

2. Tworzenie rozruchowego dysku Ubuntu-1804-lts

  1. Otwórz Cloud Console.
  2. Wybierz projekt GCP.
  3. Otwórz menu Nawigacja i wybierz Compute Engine > Dyski > Utwórz dysk.
    1. Podaj nazwę dysku. Na przykład: ubuntu1804lts
    2. Wybierz region i strefę. Aby umożliwić stosowanie zduplikowanej wirtualizacji, wybierz region i strefę, które obsługują procesory Haswell (lub nowsze). Więcej informacji znajdziesz w artykule Regiony i strefy.
    3. Wybierz obraz źródłowy ubuntu-1804-bionic-v20210211
    4. Ustaw odpowiedni rozmiar dysku (zalecane co najmniej 100 GB).

Rysunek 2. Utwórz dysk rozruchowy Ubuntu.

3. Tworzenie obrazu niestandardowego za pomocą specjalnego klucza licencyjnego w celu włączenia VMX

  1. Otwórz Cloud Console.
  2. Otwórz Cloud Shell i użyj tego polecenia: 
    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"
    • Wpisz nazwę obrazu. Na przykład: aaos-emulator-image
    • Ustaw opcję Dysk strefy na strefę, w której został utworzony dysk.
    • Ustaw nazwę dysku na nazwę użytą do utworzenia dysku.

    Przykład:

    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"

Więcej informacji znajdziesz w artykule Nested Virtualization VM Instance (w języku angielskim).

4. Tworzenie instancji maszyny wirtualnej przy użyciu niestandardowego obrazu

  1. Otwórz Cloud Console.
  2. Wybierz projekt GCP.
  3. Kliknij Menu nawigacyjne > Compute Engine > VM instance (Instalacja maszyny wirtualnej).

    Rysunek 3. Utwórz maszynę wirtualną.

  4. Wpisz nazwę instancji. Na przykład: aaosemulator
  5. Wybierz odpowiednią rodzinę i typ maszyny. Upewnij się, że maszyna ma 4 procesory wirtualne i co najmniej 16 GB pamięci.
  6. Wybierz platformę procesora Intel Cascade Lake (lub nowszą).
  7. Zmień dysk rozruchowy na obraz utworzony w poprzednim kroku.
  8. Włącz zaporę sieciową:
    • Zezwalanie na ruch HTTP
    • Zezwalanie na ruch HTTPS

5. Skonfiguruj zaporę sieciową, aby otworzyć porty 80 i 443

  1. Otwórz Cloud Console.
  2. wybierz projekt GCP.
  3. Kliknij Menu nawigacyjne > Compute Engine > instancja maszyny wirtualnej > Skonfiguruj regułę zapory.

Instalowanie wymaganego oprogramowania w maszynie wirtualnej

  1. Zainstaluj Pythona 3 i Pythona 3-env: 
    sudo apt update
sudo apt install python3
sudo apt-get install python3-venv
  2. Zainstaluj Android SDK i ADB na ścieżce. 
    sudo apt install android-sdk

    Aby zainstalować Dockera i Docker-compose, zapoznaj się z artykułami Docker i Docker-compose. Upewnij się, że możesz uruchomić te polecenia jako użytkownik inny niż root.

  3. Aby sprawdzić, czy procesor obsługuje wirtualizację sprzętową (polecenie powinno zwrócić liczbę różną od 0): 
    egrep -c '(vmx|svm)' /proc/cpuinfo
  4. Zainstaluj maszynę wirtualną jądra (KVM). Aby zainstalować KVM, uruchom: 
    sudo apt-get install qemu-kvm libvirt-daemon-system libvirt-clients bridge-utils
  5. Aby sprawdzić, czy KVM działa: 
    sudo apt install cpu-checker
kvm-ok
    Wynik: 
    INFO: /dev/kvm exists
KVM acceleration can be used
  6. Aby zainstalować Node.js i Node Packet Manager (NPM): 
    sudo apt install nodejs npm

Uruchom hostowane kontenery.

  1. Aby sprawdzić instalację, uruchom hostowane kontenery emulatora Androida z publicznego repozytorium. Szczegółowe informacje o kontenerach znajdziesz tutaj. Możesz teraz uruchomić te kontenery bez ich kompilowania. Przykład: 
    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

    W ten sposób pobierasz kontener (jeśli nie jest dostępny lokalnie) i uruchamiasz go.

  2. Po uruchomieniu kontenera połącz się z urządzeniem, konfigurując ADB w taki sam sposób jak w przypadku połączenia z AVD na lokalnym hoście. Przykład: 
    adb connect localhost:5555
adb devices
    Dane wyjściowe powinny wyglądać tak: 
    List of devices attached
localhost:5555 device

Konfigurowanie usługi AAOS Emulator

Aby skonfigurować usługę emulatora:

  1. Zainstaluj skrypt kontenera Dockera emulatora Androida: 
    git clone https://github.com/google/android-emulator-container-scripts.git

    cd android-emulator-container-script
source ./configure.sh
  2. Spowoduje to aktywowanie środowiska wirtualnego i udostępni plik wykonywalny emu-docker. Aby uzyskać szczegółowe informacje o jej użyciu, uruchom ją: 
    emu-docker -h
  3. Aby utworzyć kontenery Dockera, zaakceptuj umowy licencyjne.
  4. Utwórz kontener Dockera AAOS Emulator.
  5. Pobierz wersję emulatora nowszą niż 7154743. Przykład: 
    sdk-repo-linux-emulator-7154743.zip
  6. Pobierz obraz systemu emulatora AAOS. Na przykład: sdk-repo-linux-system-images-7115454.zip: 
    emu-docker create <emulator-zip> <system-image-zip>
  7. Utwórz kontenery internetowe i ustaw nazwę użytkownika oraz hasło do dostępu zdalnego. 
    ./create_web_container.sh -p user1,passwd1
  8. Uruchom usługę internetową emulatora AAOS: 
    docker-compose -f js/docker/docker-compose-build.yaml -f js/docker/development.yaml up

Udało Ci się uruchomić usługę internetową emulatora AAOS. Aby uzyskać do niego dostęp w przeglądarce:

https://<VM_External__IP>

Rozwiązywanie problemów

Jeśli wystąpi błąd połączenia z zewnętrznym adresem IP maszyny wirtualnej, sprawdź, czy maszyna wirtualna jest skonfigurowana tak, aby zezwalać na ruch HTTP i HTTPS. Aby to sprawdzić, zapoznaj się z artykułem Uruchamianie podstawowego serwera WWW Apache.

Konfigurowanie serwera kolejek

Możesz zawsze użyć własnego serwera. Poniżej znajduje się przykład instancji maszyny wirtualnej Google Cloud.

Uwaga: aby serwer turn działał na instancji maszyny wirtualnej Google Cloud, skonfiguruj regułę zapory maszyny wirtualnej tak, aby zezwalała na ruch na portach TCP i UDP 3478 oraz 3479.

  1. Zainstaluj serwer coturn: 
    sudo apt install coturn
systemctl stop coturn
echo "TURNSERVER_ENABLED=1"|sudo tee -a /etc/default/coturn
  2. Zmodyfikuj plik /etc/turnserver.conf, dodając te wiersze: 
    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. Zmodyfikuj plik Docker Compose YAML, aby uwzględnić konfigurację TURN: 
    cd android-emulator-container-script
nano  js/docker/docker-compose-build.yaml
  4. W sekcji emulatora dodaj te 2 wiersze kodu środowiska: 
         shm_size: 128M
     expose:
       - "8554"
+    environment:
+       - TURN=printf $SNIPPET
  5. Ponownie uruchom usługę AAOS Emulator z konfiguracją turn. Pamiętaj, aby zastąpić podane niżej adresy IP serwera turn, nazwę użytkownika i dane logowania własnymi: 
    export SNIPPET="{\"iceServers\":[{\"urls\":\"turn:35.193.52.134:3478\",\"username\":\"test\",\"credential\":\"test123\"}]}"
docker-compose -f js/docker/docker-compose-build.yaml up