Zbuduj własny emulator chmury

Na tej stronie opisano, jak uruchomić emulator AAOS jako usługę internetową i uruchomić go w przeglądarce internetowej, aby udostępnić go użytkownikom zdalnie. Dzięki temu uzyskasz kompleksowe, minimalnie wykonalne odniesienie za pośrednictwem Google Cloud Compute Engine . To powiedziawszy, możesz korzystać z tej usługi na dowolnej wybranej platformie chmury publicznej lub prywatnej.

Zamiar

Ta scentralizowana konfiguracja i konfiguracja sprawiają, że emulator AAOS jest dostępny dla całej firmy, dostawcy i programistów pracujących w domu. Dzięki temu zarządzanie emulatorem AAOS i jego aktualizacja do nowych wersji staje się bardziej efektywne, a także eliminuje czas potrzebny na konfigurowanie i zarządzanie lokalnymi maszynami dla indywidualnych użytkowników. To rozwiązanie optymalizuje wykorzystanie zasobów sprzętowych i umożliwia tańsze środowisko tworzenia aplikacji. Na przykład w celach:

  • Badania użytkowników, przegląd doświadczeń użytkowników, obsługa klienta i szkolenia.
  • Demo dla potencjalnych klientów oraz w kanałach sprzedaży.
  • Testuj, sprawdzaj, a nawet debuguj aplikacje (w tym codzienne kompilacje OEM HMI) na dużą skalę. Potraktuj emulator jako substytut stanowisk testowych używanych do tworzenia aplikacji.
  • Agenci call center klientów OEM mają jednolity, łatwo dostępny interfejs HU.

Korzyści z używania emulatora AAOS są liczne:

  • Użyj skryptu instalacyjnego, aby utworzyć dostosowany i oparty na chmurze emulator AAOS (emulator chmury).
  • Utwórz dostosowany obraz emulatora chmury AAOS dla instancji maszyn wirtualnych:
    • Gotowa konfiguracja emulatora opartego na chmurze.
    • Publiczne obrazy AAOS AVD dostępne dla twórcy usługi w celu uruchomienia AAOS AVD za pomocą polecenia. Na przykład publiczne obrazy AVD OEM jako próbki do dostosowania i zastosowania przez partnerów.

Architektura

Architekturę przykładowego emulatora chmury przedstawiono poniżej. Twoja pierwsza minimalnie opłacalna usługa będzie działać po dodaniu własnych obrazów AVD OEM.

Rysunek 1. Architektura Cloud AVD.

Kluczowe elementy składowe emulatora to:

Tutaj .
Przedmiot Zamiar
Emulator Androida Instancja emulatora obsługuje obrazy AVD
Most Goldfish-webrtc Aplikacja dla systemu Linux zapewniająca komunikację między aplikacją reagującą a emulatorem AAOS
emulator androida-webrtc Aplikacja Reaguj , aby wyświetlić interfejs emulatora w przeglądarce internetowej. React przechwytuje także zdarzenia wprowadzane przez użytkownika i wysyła je z powrotem na serwer.
Skrypty kontenerowe emulatora Androida Skrypty Pythona do zarządzania i tworzenia obrazów i kontenerów Dockera dla powyższych modułów oprogramowania.
Generuje tokeny do zarządzania uprawnieniami dostępu emulatora.
Włącz serwer Ustanawia bezpośrednie połączenie WebRTC między klientem a serwerem. Serwer Turn jest wymagany tylko wtedy, gdy usługa Emulator działa za zaporami ogniowymi lub serwerami proxy.
Wysłannik

Usługa proxy do:

  • Zapewnij protokół HTTPS przy użyciu certyfikatu z podpisem własnym.
  • Przekieruj ruch na porcie 80 (http) na port 443 (https).
  • Działaj jako serwer proxy gRPC dla emulatora.
  • Sprawdź tokeny, aby zezwolić na dostęp do punktu końcowego gRPC emulatora.
  • Przekieruj inne żądania do komponentu Nginx, który hostuje aplikację React.

Skonfiguruj emulator na maszynie wirtualnej w chmurze

Aby utworzyć projekt GCP:

  1. Przejdź do Google Cloud Console i wybierz projekt .
  2. Aby upewnić się, że rozliczenia są włączone w Twoim projekcie Google Cloud, zobacz Włączanie, wyłączanie i zmienianie rozliczeń w projekcie .
  3. Włącz interfejs API .

Utwórz maszynę wirtualną z systemem Linux w GCE

1. Włącz wirtualizację zagnieżdżoną

Domyślnie wirtualizacja zagnieżdżona jest dozwolona na poziomie projektu, folderu lub organizacji. Jeśli ktoś w Twojej organizacji nie wyłączył wirtualizacji zagnieżdżonej , nie musisz nic robić, aby ją włączyć.

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

2. Utwórz dysk startowy Ubuntu-1804-lts

  1. Przejdź do Konsoli Chmury .
  2. Wybierz projekt GCP.
  3. Przejdź do menu Nawigacja i wybierz Compute Engine > Dyski > Utwórz dysk .
    1. Podaj nazwę dysku. Na przykład ubuntu1804lts
    2. Wybierz region i strefę. Aby obsługiwać wirtualizację zagnieżdżoną, upewnij się, że wybrany region i strefa obsługują procesory Haswell (lub nowsze). Aby dowiedzieć się więcej, zobacz Regiony i Strefy .
    3. Wybierz obraz źródłowy ubuntu-1804-bionic-v20210211
    4. Ustaw odpowiedni rozmiar dysku (zalecane jest 100 GB lub więcej).

Rysunek 2. Utwórz dysk startowy Ubuntu.

3. Utwórz niestandardowy obraz ze specjalnym kluczem licencyjnym, aby włączyć VMX

  1. Przejdź do konsoli Cloud .
  2. Otwórz Cloud Shell i użyj następującego 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"
    • Wprowadź nazwę obrazu. Na przykład aaos-emulator-image
    • Ustaw Strefę dysku na strefę, w której utworzyłeś dysk.
    • Ustaw nazwę dysku na nazwę użytą do utworzenia dysku.

    Na 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"

Aby uzyskać szczegółowe informacje, zobacz Instancja maszyny wirtualnej zagnieżdżonej wirtualizacji .

4. Utwórz instancję maszyny wirtualnej, korzystając z dostosowanego obrazu

  1. Przejdź do Konsoli Chmury .
  2. Wybierz projekt GCP.
  3. Wybierz kolejno Menu nawigacyjne > Compute Engine > Instancja maszyny wirtualnej.

    Rysunek 3. Utwórz instancję maszyny wirtualnej.

  4. Wprowadź nazwę instancji. Na przykład aaosemulator
  5. Wybierz żądaną rodzinę maszyn i typ. Upewnij się, że maszyna zawiera cztery procesory wirtualne i 16 GB pamięci (lub więcej).
  6. Wybierz platformę procesora Intel Cascade Lake (lub nowszą).
  7. Zmień dysk rozruchowy na obraz utworzony w poprzednim kroku.
  8. Włącz zaporę sieciową dla:
    • Zezwalaj na ruch HTTP
    • Zezwalaj na ruch HTTPS

5. Skonfiguruj zaporę sieciową tak, aby otwierała porty 80 i 443

  1. Przejdź do Konsoli Chmury .
  2. wybierz projekt GCP.
  3. Wybierz kolejno Menu nawigacyjne > Compute Engine > Instancja maszyny wirtualnej > Skonfiguruj regułę zapory sieciowej.

Zainstaluj wymagane oprogramowanie na maszynie wirtualnej

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

    Aby zainstalować Docker i Docker-compose, zobacz Docker i Docker-compose . Upewnij się, że możesz je uruchomić jako użytkownik inny niż root .

  3. Aby potwierdzić, że procesor obsługuje wirtualizację sprzętową (polecenie powinno dać liczbę niezerową):
    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
    Wynikiem powinno być:
    INFO: /dev/kvm exists
KVM acceleration can be used
  6. Aby zainstalować Node.js i Menedżera pakietów węzła (NPM):
    sudo apt install nodejs npm

Uruchom hostowane kontenery

  1. Aby zweryfikować instalację, uruchom hostowane kontenery emulatora Androida z publicznego repozytorium. Szczegóły dotyczące kontenerów znajdziesz tutaj . Możesz teraz uruchamiać te kontenery bez ich budowania. Na 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

    Spowoduje to ściągnięcie kontenera (jeśli nie jest on dostępny lokalnie) i uruchomienie go.

  2. Po uruchomieniu kontenera połącz się z urządzeniem, konfigurując ADB w taki sam sposób, jak podłączasz AVD na hoście lokalnym. Na przykład:
    adb connect localhost:5555
adb devices
    Wynikiem powinno być:
    List of devices attached
localhost:5555 device

Skonfiguruj usługę emulatora AAOS

Aby skonfigurować usługę Emulator:

  1. Zainstaluj skrypt kontenera Docker emulatora systemu Android:
    git clone https://github.com/google/android-emulator-container-scripts.git

    cd android-emulator-container-script
source ./configure.sh
  2. Aktywuje to środowisko wirtualne i udostępnia wykonywalny emu-docker. Aby uzyskać szczegółowe informacje na temat jego użycia, uruchom go:
    emu-docker -h
  3. Aby utworzyć kontenery Docker, zaakceptuj umowy licencyjne.
  4. Zbuduj kontener dokowany emulatora AAOS.
  5. Pobierz kompilację emulatora nowszą niż wersja 7154743. Na 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 i hasło 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

Pomyślnie uruchomiłeś usługę internetową emulatora AAOS! Aby uzyskać do niego dostęp w przeglądarce internetowej, użyj następujących poleceń:

https://<VM_External__IP>

Rozwiązywanie problemów

Jeśli wystąpi błąd połączenia z zewnętrznym adresem IP maszyny wirtualnej, upewnij się, że maszyna wirtualna jest skonfigurowana tak, aby zezwalała na ruch HTTP i HTTPS. Aby to sprawdzić, zobacz Uruchamianie podstawowego serwera WWW Apache .

Skonfiguruj serwer zwrotny

Zawsze możesz skorzystać z własnego serwera turowego. Poniżej znajduje się przykład w instancji maszyny wirtualnej Google Cloud.

Uwaga: aby serwer turn działał na instancji maszyny wirtualnej Google Cloud, pamiętaj o skonfigurowaniu reguły zapory sieciowej maszyny wirtualnej tak, aby zezwalała na ruch na portach TCP i UDP 3478 i 3479.

  1. Zainstaluj serwer zwrotny:
    sudo apt install coturn
systemctl stop coturn
echo "TURNSERVER_ENABLED=1"|sudo tee -a /etc/default/coturn
  2. Zmodyfikuj /etc/turnserver.conf dodając następujące 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 YAML Docker Compose, aby uwzględnić konfigurację TURN:
    cd android-emulator-container-script
nano  js/docker/docker-compose-build.yaml
  4. Dodaj następujące dwie linie środowiska w sekcji emulatora:
         shm_size: 128M
     expose:
       - "8554"
+    environment:
+       - TURN=printf $SNIPPET
  5. Uruchom ponownie usługę emulatora AAOS z konfiguracją kolei. Pamiętaj, aby zastąpić adres IP serwera Turn, nazwę użytkownika i dane uwierzytelniające poniżej 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