Costruisci il tuo emulatore cloud

Questo articolo descrive come eseguire l' emulatore AAOS come servizio Web ed eseguirlo in un browser Web per renderlo accessibile in remoto agli utenti. In questo modo viene fornito un riferimento end-to-end minimamente valido tramite Google Cloud Compute Engine . Detto questo, puoi utilizzare questo servizio su qualsiasi piattaforma cloud pubblica o privata di tua scelta.

Scopo

Questa configurazione e configurazione centralizzate rendono l'emulatore AAOS accessibile a un'intera azienda, fornitore e sviluppatori di lavoro da casa. Ciò rende più efficiente la gestione e l'aggiornamento dell'emulatore AAOS alle nuove versioni ed elimina il tempo necessario per configurare e gestire le macchine locali per i singoli utenti. Questa soluzione ottimizza l'uso delle risorse hardware e consente un ambiente di sviluppo di app a basso costo. Ad esempio, ai fini di:

  • Ricerca degli utenti, revisione dell'esperienza utente, assistenza clienti e formazione.
  • Demo a potenziali clienti e nei canali di vendita.
  • Testare, convalidare e persino eseguire il debug delle app (comprese le build HMI OEM giornaliere) su larga scala. Considera l'emulatore un sostituto dei banchi di prova utilizzati per sviluppare app.
  • Gli agenti dei call center dei clienti OEM dispongono di un'interfaccia utente HU uniforme e di facile accesso.

I vantaggi dell'utilizzo dell'emulatore AAOS sono numerosi:

  • Usa uno script di installazione per creare un emulatore AAOS personalizzato e basato su cloud (emulatore cloud).
  • Crea un'immagine dell'emulatore cloud AAOS personalizzata per le istanze VM:
    • Configurazione pronta di un emulatore basato su cloud.
    • Immagini pubbliche AAOS AVD disponibili al creatore del servizio per avviare un AAOS AVD con un comando. Ad esempio, immagini AVD OEM pubbliche come campioni per i partner da adattare e applicare.

Architettura

L'architettura dell'esempio di emulatore cloud è illustrata di seguito. Il tuo primo servizio minimamente valido funzionerà aggiungendo le tue immagini AVD OEM.

Figura 1. Architettura Cloud AVD

Gli elementi costitutivi chiave dell'emulatore sono:

Elemento Scopo
Emulatore Android L'istanza dell'emulatore ospita immagini AVD
Ponte Goldfish-webrtc Applicazione Linux per fornire la comunicazione tra l'app react e l'emulatore AAOS
emulatore-android-webrtc Reagire all'applicazione per visualizzare l'interfaccia utente dell'emulatore in un browser web. React acquisisce anche gli eventi di input dell'utente e li rimanda al server.
Script del contenitore dell'emulatore Android Script Python per gestire e creare immagini e contenitori Docker per i moduli software di cui sopra.
Servizio JWT (servizio token Web JSON) Genera token per gestire i permessi di accesso dell'emulatore.
Diventa server Stabilisce una connessione diretta WebRTC tra il client e il server. Turn server è richiesto solo quando il servizio Emulator è in esecuzione dietro firewall o proxy.
Inviato

Un servizio proxy per:

  • Fornisci HTTPS utilizzando un certificato autofirmato.
  • Reindirizza il traffico dalla porta 80 (http) alla porta 443 (https).
  • Agire come proxy gRPC per l'emulatore.
  • Verifica i token per consentire l'accesso all'endpoint gRPC dell'emulatore.
  • Reindirizza altre richieste al componente Nginx, che ospita un'applicazione React.

Configura l'emulatore su una macchina virtuale cloud

Per creare un progetto GCP:

  1. Vai su Google Cloud Console e seleziona un progetto .
  2. Per confermare che la fatturazione è abilitata per il tuo progetto Google Cloud, consulta Abilitare, disabilitare o modificare la fatturazione per un progetto .
  3. Abilita l'API .

Crea una macchina virtuale Linux in GCE

1. Abilita la virtualizzazione nidificata

Per impostazione predefinita, la virtualizzazione nidificata è consentita a livello di progetto, cartella o organizzazione. A meno che qualcuno nella tua organizzazione non abbia disabilitato la virtualizzazione nidificata , non devi fare nulla per abilitarla.

  1. Utilizzare lo strumento da riga di comando gcloud per confermare che la virtualizzazione nidificata è consentita:
    gcloud beta resource-manager org-policies describe   \
  constraints/compute.disableNestedVirtualization  --effective --project=[PROJECT_ID]

2. Crea un disco avviabile Ubuntu-1804-lts

  1. Vai a Cloud Console .
  2. Seleziona il progetto GCP.
  3. Vai al menu di navigazione > Compute Engine > Dischi > Crea disco.
    1. Fornisci un nome del disco. Ad esempio, ubuntu1804lts
    2. Seleziona una regione e una zona. Per supportare la virtualizzazione nidificata, assicurati che la regione e la zona selezionate supportino i processori Haswell (o successivi). Per ulteriori informazioni, consulta Regioni e zone .
    3. Seleziona l'immagine sorgente di ubuntu-1804-bionic-v20210211
    4. Impostare una dimensione del disco appropriata (si consigliano 100 GB o più).

Figura 1. Crea il disco di avvio di Ubuntu

3. Crea un'immagine personalizzata con una chiave di licenza speciale per abilitare VMX

  1. Vai alla console cloud .
  2. Apri una Cloud Shell e usa il comando seguente:
    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"
    • Immettere un nome immagine. Ad esempio, aaos-emulator-image
    • Imposta Disk Zone sulla zona in cui hai creato il disco.
    • Imposta il nome del disco sul nome utilizzato per creare il disco.

    Per esempio:

    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"

Per i dettagli, consulta Istanza di virtualizzazione nidificata VM .

4. Crea un'istanza VM utilizzando l'immagine personalizzata

  1. Vai a Cloud Console .
  2. Seleziona il progetto GCP.
  3. Vai a Menu di navigazione > Compute Engine > Istanza VM.

    Figura 1. Creare un'istanza VM

  4. Immettere un nome di istanza. Ad esempio, aaosemulator
  5. Selezionare la famiglia e il tipo di macchina desiderati. Assicurati che la macchina contenga quattro vCPU e 16 GB di memoria (o più).
  6. Seleziona la piattaforma CPU come Intel Cascade Lake (o successiva).
  7. Modificare il disco di avvio con l'immagine creata nel passaggio precedente.
  8. Abilita Firewall per:
    • Consenti traffico HTTP
    • Consenti traffico HTTPS

5. Configurare il firewall per aprire le porte 80 e 443

  1. Vai a Cloud Console .
  2. selezionare il progetto GCP.
  3. Vai a Menu di navigazione > Compute Engine > Istanza VM > Imposta regola firewall.

Installa il software richiesto sulla macchina virtuale

  1. Installa Python 3 e Python3-env:
    sudo apt update
sudo apt install python3
sudo apt-get install python3-venv
  2. Installa Android SDK e ADB disponibili nel percorso.
    sudo apt install android-sdk

    Per installare Docker e Docker-compose, consulta Docker e Docker-compose . Assicurati di poterli eseguire come utente non root .

  3. Per confermare che la CPU supporta la virtualizzazione hardware (il comando dovrebbe risultare in un numero diverso da zero):
    egrep -c '(vmx|svm)' /proc/cpuinfo
  4. Installa la macchina virtuale del kernel (KVM). Per installare KVM, eseguire:
    sudo apt-get install qemu-kvm libvirt-daemon-system libvirt-clients bridge-utils
  5. Per verificare che KVM funzioni:
    sudo apt install cpu-checker
kvm-ok
    L'output dovrebbe essere:
    INFO: /dev/kvm exists
KVM acceleration can be used
  6. Per installare Node.js e Node Packet Manager (NPM):
    sudo apt install nodejs npm

Avvia i contenitori ospitati

  1. Per verificare l'installazione, esegui i contenitori dell'emulatore Android ospitato dal repository pubblico. Puoi trovare i dettagli sui contenitori qui . Ora puoi eseguire questi contenitori senza crearli. Ad esempio:
    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

    Questo tira verso il basso il contenitore (se non è disponibile localmente) e lo avvia.

  2. Quando il container viene avviato, connettiti al dispositivo configurando ADB nello stesso modo in cui connetti un AVD su un host locale. Ad esempio:
    adb connect localhost:5555
adb devices
    L'output dovrebbe essere:
    List of devices attached
localhost:5555 device

Configura il servizio emulatore AAOS

Per configurare il servizio Emulatore:

  1. Installa lo script del contenitore Docker dell'emulatore Android:
    git clone https://github.com/google/android-emulator-container-scripts.git

    cd android-emulator-container-script
source ./configure.sh
  2. Questo attiva un ambiente virtuale e rende disponibile l'eseguibile emu-docker. Per ottenere informazioni dettagliate sul suo utilizzo, avviarlo:
    emu-docker -h
  3. Per creare i contenitori Docker, accetta i contratti di licenza.
  4. Crea il contenitore Docker dell'emulatore AAOS.
  5. Scarica una build dell'emulatore successiva alla versione 7154743. Ad esempio:
    sdk-repo-linux-emulator-7154743.zip
  6. Scarica l'immagine del sistema dell'emulatore AAOS. Ad esempio, sdk-repo-linux-system-images-7115454.zip :
    emu-docker create <emulator-zip> <system-image-zip>
  7. Crea i Web Container e imposta nome utente e password per l'accesso remoto.
    ./create_web_container.sh -p user1,passwd1
  8. Avvia il servizio Web dell'emulatore AAOS:
    docker-compose -f js/docker/docker-compose-build.yaml -f js/docker/development.yaml up

Hai avviato con successo un servizio Web emulatore AAOS! Utilizzare quanto segue per accedervi su un browser web:

https://<VM_External__IP>

Risoluzione dei problemi

Se si verifica un errore di connessione all'IP esterno della macchina virtuale, assicurarsi che la macchina virtuale sia configurata per consentire sia il traffico HTTP che HTTPS. Per convalidare questo, vedere Esecuzione di un server Web Apache di base .

Configura il turn server

Puoi sempre usare il tuo turn server. Di seguito è riportato un esempio su un'istanza di Google Cloud VM.

Nota: per far funzionare il turn server su un'istanza di Google Cloud VM, assicurati di configurare la regola del firewall VM per consentire il traffico sulle porte TCP e UDP 3478 e 3479.

  1. Installare il server coturn:
    sudo apt install coturn
systemctl stop coturn
echo "TURNSERVER_ENABLED=1"|sudo tee -a /etc/default/coturn
  2. Modificare /etc/turnserver.conf aggiungendo le seguenti righe:
    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. Modifica il file Docker Compose YAML per includere la configurazione TURN:
    cd android-emulator-container-script
nano  js/docker/docker-compose-build.yaml
  4. Aggiungi le seguenti due righe di ambiente nella sezione dell'emulatore:
         shm_size: 128M
     expose:
       - "8554"
+    environment:
+       - TURN=printf $SNIPPET
  5. Riavvia il servizio AAOS Emulator con la configurazione turn. Assicurati di sostituire l'IP, il nome utente e le credenziali del turn server di seguito con i tuoi:
    export SNIPPET="{\"iceServers\":[{\"urls\":\"turn:35.193.52.134:3478\",\"username\":\"test\",\"credential\":\"test123\"}]}"
docker-compose -f js/docker/docker-compose-build.yaml up