Utwórz własny emulator chmury

Na tej stronie dowiesz się, jak uruchomić emulator AAOS jako usługę internetową i uruchomić go przeglądarki internetowej, aby umożliwić użytkownikom zdalny dostęp do niej. Dzięki temu uzyskasz całościowy, jak najmniej uzasadnionego odniesienia przy użyciu Google Cloud. Compute Engine. Możesz jednak korzystać z tej usługi na dowolnej platformie w chmurze publicznej lub prywatnej.

Cel

Ta scentralizowana konfiguracja sprawia, że emulator AAOS jest dostępny dla całej firmy, z dostawcami usług i programistami pracującymi z domu. Zwiększa to efektywność zarządzania i uaktualniania dzięki emulatorowi AAOS do nowych wersji, co pozwala skrócić czas potrzebny na skonfigurowanie komputerów lokalnych i zarządzanie nimi. dla poszczególnych użytkowników. To rozwiązanie optymalizuje wykorzystanie zasobów sprzętowych i umożliwia tańsze środowisko tworzenia aplikacji. Przykłady:

  • Badania opinii użytkowników, weryfikowanie wrażeń użytkowników, obsługa klienta i szkolenia.
  • Prezentacje dla potencjalnych klientów i w kanałach sprzedaży.
  • Testuj, weryfikuj, a nawet debuguj aplikacje (w tym codzienne kompilacje HMI OEM) na dużą skalę. Rozważ emulatora, który zastępuje inne platformy testowe do tworzenia aplikacji.
  • Pracownicy centrum obsługi klienta OEM mają jednolity i łatwy dostęp do interfejsu HU.

Używanie emulatora AAOS ma wiele zalet:

  • Użyj skryptu konfiguracji, aby utworzyć dostosowany, działający w chmurze emulator AAOS (emulator chmury).
  • Utwórz niestandardowy obraz emulatora Cloud AAOS dla instancji maszyn wirtualnych:
    • Gotowe do skonfigurowania emulatora działającego w chmurze.
    • Publiczne obrazy AVD AAOS dostępne dla twórcy usługi w celu uruchomienia AAOS AVD polecenia. Dotyczy to na przykład publicznych obrazów AVD OEM, które partnerzy mogą dostosowywać i stosować.

Architektura

Poniżej przedstawiono architekturę emulatora chmury. Twoje pierwsze aby usługa była jak minimalnie realna, wystarczy dodać własne obrazy AVD OEM.

Rysunek 1. Architektura Cloud AVD.

Kluczowe elementy składowe emulatora to:

tutaj.
Produkt Cel
Emulator Androida Instancja emulatora hostuje obrazy AVD
Most złoty w internecie Aplikacja na Linuksa zapewniająca komunikację między aplikacją reakcji a emulatorem AAOS
emulator-webrtc React, aby wyświetlić interfejs emulatora w internecie. przeglądarki. React rejestruje też zdarzenia wejściowe użytkownika i wysyła je z powrotem do serwera.
Skrypty kontenera emulatora Androida Skrypty w języku Python służące do tworzenia obrazów i kontenerów Dockera oraz zarządzania nimi na potrzeby powyższych modułów oprogramowania.
Generuje tokeny do zarządzania uprawnieniami dostępu emulatora.
Włącz serwer Nawiązuje bezpośrednie połączenie WebRTC między klientem a serwerem. Włącz serwer jest wymagane tylko wtedy, gdy usługa emulatora działa za zaporami sieciowymi lub serwerami proxy.
Envoy

Usługa pośrednicząca w:

  • Udostępnij protokół HTTPS za pomocą podpisanego samodzielnie certyfikatu.
  • Przekieruj ruch przez port 80 (http) na port 443 (https).
  • Pełni rolę serwera proxy gRPC dla emulatora.
  • Zweryfikuj tokeny, aby zezwolić na dostęp do punktu końcowego gRPC emulatora.
  • Przekieruj 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 Wybierz projekt.
  2. Aby sprawdzić, czy w projekcie Google Cloud włączone są płatności, zobacz Włączanie, wyłączanie i zmienianie rozliczeń w projekcie .
  3. włączyć interfejs API.

Tworzenie w GCE maszyny wirtualnej z systemem Linux

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

Domyślnie zagnieżdżona wirtualizacja jest dozwolona na poziomie projektu, folderu lub organizacji. Chyba że ktoś w organizacji wyłączono zagnieżdżoną wirtualizację, nie musisz nic robić, aby go włączyć.

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

2. Tworzenie dysku rozruchowego Ubuntu-1804-LTs

  1. Otwórz Konsola Cloud.
  2. Wybierz projekt GCP.
  3. Otwórz menu nawigacyjne i wybierz Compute Engine > Dyski > Utwórz dysk.
    1. Podaj nazwę dysku. Na przykład: ubuntu1804lts
    2. Wybierz region i strefę. Aby obsługiwać zagnieżdżoną wirtualizację, upewnij się, że region i wybrana strefa obsługują procesory Haswell (lub nowsze). Więcej informacji: Regiony i strefy.
    3. Wybierz obraz źródłowy produktu ubuntu-1804-bionic-v20210211
    4. Ustaw odpowiedni rozmiar dysku (zalecane 100 GB lub więcej).

Rysunek 2. Utwórz dysk rozruchowy Ubuntu.

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

  1. Otwórz konsolę Cloud.
  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 strefę dysku na strefę, w której został utworzony dysk.
    • Wpisz nazwę dysku użytą do jego utworzenia.

    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"

Więcej informacji: Maszyna wirtualna Nested Virtualization

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

  1. Otwórz konsolę Cloud.
  2. Wybierz projekt GCP.
  3. Wybierz Menu nawigacyjne > Compute Engine > maszynie wirtualnej.

    Rysunek 3. utworzyć instancję maszyny wirtualnej,

  4. Wpisz nazwę instancji. Na przykład: aaosemulator
  5. Wybierz odpowiednią rodzinę i typ maszyn. Sprawdź, czy maszyna zawiera 4 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 otworzyć port 80 i 443

  1. Otwórz konsolę Cloud.
  2. wybierz projekt GCP.
  3. Wybierz Menu nawigacyjne > Compute Engine > Instancja maszyny wirtualnej > Skonfiguruj regułę zapory sieciowej.

Zainstaluj wymagane oprogramowanie w maszynie wirtualnej

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

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

  3. Aby sprawdzić, czy procesor obsługuje wirtualizację sprzętową (polecenie powinno zwrócić polecenie liczba różna od zera): 
    egrep -c '(vmx|svm)' /proc/cpuinfo
  4. Zainstaluj maszynę wirtualną jądra. Aby zainstalować KVM, uruchom polecenie: 
    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
    Dane wyjściowe powinny wyglądać tak: 
    INFO: /dev/kvm exists
KVM acceleration can be used
  6. Aby zainstalować środowiska Node.js i menedżera pakietów Node.js (NPM): 
    sudo apt install nodejs npm

Uruchom hostowane kontenery

  1. Aby sprawdzić instalację, uruchom hostowane kontenery emulatora Androida z publicznych źródeł. z repozytorium. Szczegółowe informacje o kontenerach znajdziesz tutaj. Teraz możesz uruchamiać te kontenery bez ich tworzenia. 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 pobranie kontenera (jeśli nie jest on dostępny lokalnie) i jego uruchomienie.

  2. Po uruchomieniu kontenera połącz się z urządzeniem, konfigurując ADB w ten sam sposób jak podłączenie AVD na hoście lokalnym. Na 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 emulatora AAOS

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ępnienie wykonywalnego emu-dockera. Aby uzyskać szczegółowe informacje o jego użyciu, uruchom go: 
    emu-docker -h
  3. Aby utworzyć kontenery Dockera, zaakceptuj umowy licencyjne.
  4. Utwórz kontener Dockera 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. 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 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

Usługa internetowa emulatora AAOS została uruchomiona. Użyj opcji poniżej, aby uzyskać 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 konfiguracja maszyny wirtualnej zezwala na to zarówno ruch HTTP, jak i HTTPS. Aby to sprawdzić, zobacz Uruchomienie podstawowego serwera WWW Apache.

Konfiguracja serwera zakrętu

Zawsze możesz użyć własnego serwera turowego. Poniżej znajdziesz przykład na maszynie wirtualnej Google Cloud instancji.

Uwaga: aby serwer obsługi działał w instancji maszyny wirtualnej Google Cloud, skonfigurować regułę zapory sieciowej 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 /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 YAML Docker Compose tak, aby zawierał konfigurację TURN: 
    cd android-emulator-container-script
nano  js/docker/docker-compose-build.yaml
  4. Dodaj w sekcji emulatora te 2 wiersze środowiska: 
         shm_size: 128M
     expose:
       - "8554"
+    environment:
+       - TURN=printf $SNIPPET
  5. Ponownie uruchom usługę emulatora AAOS z konfiguracją Turn. Pamiętaj, aby zastąpić poniższy adres IP, nazwę użytkownika i dane logowania własnego serwera skrętu: 
    export SNIPPET="{\"iceServers\":[{\"urls\":\"turn:35.193.52.134:3478\",\"username\":\"test\",\"credential\":\"test123\"}]}"
docker-compose -f js/docker/docker-compose-build.yaml up