Zbuduj własny emulator chmury

W tym artykule opisano, jak uruchomić emulator AAOS jako usługę sieci Web i uruchomić go w przeglądarce internetowej, aby był zdalnie dostępny dla użytkowników. W ten sposób zapewnisz kompleksową, minimalnie wykonalną referencję 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 sprawia, ż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 aktualizowanie go do nowych wersji staje się bardziej wydajne, a także eliminuje się czas potrzebny na konfigurację i zarządzanie lokalnymi maszynami dla poszczególnych 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.
  • Prezentacje dla potencjalnych klientów oraz w kanałach sprzedaży.
  • Testuj, weryfikuj, a nawet debuguj aplikacje (w tym codzienne kompilacje OEM HMI) na dużą skalę. Rozważ Emulator jako substytut stanowisk testowych używanych do tworzenia aplikacji.
  • Agenci centrum obsługi klienta OEM mają jednolity, łatwo dostępny interfejs użytkownika HU.

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

  • Użyj skryptu instalacyjnego, aby utworzyć dostosowany i oparty na chmurze emulator AAOS (emulator w chmurze).
  • 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 adaptacji i zastosowania przez partnerów.

Architektura

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

Rysunek 1. Architektura AVD w chmurze

Kluczowe bloki konstrukcyjne emulatora to:

Przedmiot Zamiar
Emulator Androida Instancja emulatora obsługuje obrazy AVD
Most Goldfish-webrtc Aplikacja Linux zapewniająca komunikację między aplikacją React a emulatorem AAOS
emulator-android-webrtc Aplikacja React do wyświetlania interfejsu użytkownika emulatora w przeglądarce internetowej. React przechwytuje również zdarzenia wejściowe użytkownika i wysyła je z powrotem na serwer.
Skrypty kontenera emulatora Androida Skrypty Python do zarządzania i tworzenia obrazów i kontenerów platformy Docker dla powyższych modułów oprogramowania.
Usługa JWT (usługa JSON Web Token) 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 lub serwerami proxy.
Wysłannik

Usługa proxy do:

  • Podaj HTTPS przy użyciu certyfikatu z podpisem własnym.
  • Przekieruj ruch na porcie 80 (http) do portu 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 obsługuje aplikację React.

Skonfiguruj emulator na maszynie wirtualnej w chmurze

Aby utworzyć projekt GCP:

  1. Przejdź do Google Cloud Console i wybierz projekt .
  2. Aby potwierdzić, że płatności są włączone dla Twojego projektu Google Cloud, zobacz Włączanie, wyłączanie lub zmienianie płatności dla projektu .
  3. Włącz interfejs API .

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

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

Domyślnie zagnieżdżona wirtualizacja 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 Cloud Console .
  2. Wybierz projekt GCP.
  3. Przejdź do menu nawigacyjnego > 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 100 GB lub większe).

Rysunek 1. Utwórz dysk startowy Ubuntu

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

  1. Przejdź do konsoli w chmurze .
  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 utworzono 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 Zagnieżdżone wystąpienie maszyny wirtualnej wirtualizacji .

4. Utwórz instancję maszyny wirtualnej za pomocą dostosowanego obrazu

  1. Przejdź do Cloud Console .
  2. Wybierz projekt GCP.
  3. Przejdź do menu nawigacyjnego > Compute Engine > instancja maszyny wirtualnej.

    Rysunek 1. Utwórz instancję maszyny wirtualnej

  4. Wpisz nazwę instancji. Na przykład aaosemulator
  5. Wybierz żądaną rodzinę maszyn i typ. Upewnij się, że maszyna zawiera cztery wirtualne procesory 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ę dla:
    • Zezwól na ruch HTTP
    • Zezwalaj na ruch HTTPS

5. Skonfiguruj zaporę, aby otworzyć port 80 i 443

  1. Przejdź do Cloud Console .
  2. wybierz projekt GCP.
  3. Przejdź do 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ć w wyniku 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
    
    Wynik powinien wyglądać następująco:
    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 zweryfikować instalację, uruchom hostowane kontenery emulatora Androida z repozytorium publicznego. 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
    

    To ściąga kontener (jeśli nie jest dostępny lokalnie) i uruchamia go.

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

Skonfiguruj usługę emulatora AAOS

Aby skonfigurować usługę Emulator:

  1. Zainstaluj skrypt kontenera Docker Emulator Androida:
    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 o jego użyciu, uruchom go:
    emu-docker -h
    
  3. Aby utworzyć kontenery Docker, zaakceptuj umowy licencyjne.
  4. Zbuduj kontener platformy Docker emulatora AAOS.
  5. Pobierz kompilację emulatora późniejszą 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 do zdalnego dostępu.
    ./create_web_container.sh -p user1,passwd1
    
  8. Uruchom usługę sieciową emulatora AAOS:
    docker-compose -f js/docker/docker-compose-build.yaml -f js/docker/development.yaml up
    

Pomyślnie uruchomiłeś usługę sieciową 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ć na ruch HTTP i HTTPS. Aby to sprawdzić, zobacz Uruchamianie podstawowego serwera WWW Apache .

Skonfiguruj serwer turn

Zawsze możesz użyć własnego serwera turowego. Poniżej znajduje się przykład na instancji Google Cloud VM.

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

  1. Zainstaluj serwer coturn:
    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 Docker Compose YAML, 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ę AAOS Emulator z konfiguracją turn. Pamiętaj, aby zastąpić poniższy adres IP serwera turn, nazwę użytkownika i dane uwierzytelniające 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