Crea il tuo emulatore cloud

In questa pagina viene descritto come eseguire AAOS Emulator come servizio web ed eseguirlo in un browser web per renderle accessibili agli utenti da remoto. In questo modo viene fornita una riferimento minimamente attuabile tramite Google Cloud Compute Engine. Detto questo, puoi utilizzare questo servizio su qualsiasi piattaforma cloud pubblica o privata di tua scelta.

Finalità

Questa configurazione e impostazione centralizzate rendono l'emulatore AAOS accessibile a un'intera azienda, e sviluppatori che lavorano da casa. In questo modo, la gestione e l'upgrade saranno più efficienti l'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 una di sviluppo delle app a basso costo. Ad esempio, ai fini di:

  • Ricerche sugli utenti, revisione dell'esperienza utente, assistenza clienti e formazione.
  • Demo per i potenziali clienti e nei canali di vendita.
  • Testa, convalida e persino debug le app (incluse le build HMI OEM giornaliere) su larga scala. Prendi in considerazione l'emulatore sostituisce i banco di prova utilizzati per sviluppare app.
  • Gli agenti dei call center dei clienti OEM dispongono di una UI HU uniforme e di facile accesso.

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

  • Usa uno script di configurazione per creare un emulatore AAOS personalizzato e basato su cloud (emulatore cloud).
  • Crea un'immagine personalizzata dell'emulatore Cloud AAOS per le istanze VM:
    • Un emulatore basato su cloud pronto per essere configurato.
    • Immagini AVD pubbliche AAOS disponibili al creatore del servizio per avviare la durata di visualizzazione media AAOS con un comando. Ad esempio, immagini della durata di visualizzazione media degli OEM pubbliche come esempi che i partner possono adattare e applicare.

Architettura

Di seguito è illustrata l'architettura dell'esempio di emulatore cloud. La tua prima il servizio minimamente efficace può essere utilizzato aggiungendo immagini di durata media dell'OEM personalizzate.

Figura 1. dell'architettura cloud AVD.

I componenti di base dell'emulatore di chiavi sono:

qui
Articolo Finalità
Emulatore Android L'istanza dell'emulatore ospita le immagini AVD
Ponte Webrtc con pesci rossi App Linux per la comunicazione tra l'app di reazione e l'emulatore AAOS
emulatore-android-webrtc App React per visualizzare l'interfaccia utente dell'emulatore sul web del browser. React acquisisce anche gli eventi di input dell'utente e li invia al server.
Script container dell'emulatore Android Script Python per gestire e creare immagini e container Docker per i moduli software sopra indicati.
Genera token per gestire le autorizzazioni di accesso dell'emulatore.
Server di turno Stabilisce una connessione diretta WebRTC tra il client e il server. Server di turno è necessaria solo quando il servizio Emulator è in esecuzione dietro firewall o proxy.
Envoy

Un servizio proxy per:

  • Fornire HTTPS utilizzando un certificato autofirmato.
  • Reindirizza il traffico sulla porta 80 (http) alla porta 443 (https).
  • Fungere da 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'app React.

Configura l'emulatore su una VM cloud

Per creare un progetto Google Cloud:

  1. Vai alla console Google Cloud Seleziona un progetto.
  2. Per verificare che la fatturazione sia abilitata per il tuo progetto Google Cloud, consulta Abilitare, disabilitare o modificare la fatturazione per un progetto .
  3. Abilita l'API.

Crea una VM Linux in GCE

1. Abilita virtualizzazione nidificata

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

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

2. Crea un disco di avvio Ubuntu-1804-lts

  1. Vai a Console Cloud.
  2. Seleziona il progetto Google Cloud.
  3. Vai al menu di navigazione e seleziona Compute Engine > Dischi > Crea disco.
    1. Specifica un nome per il disco. Ad esempio, ubuntu1804lts
    2. Seleziona una regione e una zona. Per supportare la virtualizzazione nidificata, assicurati che la regione e la Zona selezionata supportano i processori Haswell (o successivi). Per saperne di più, vedi Regioni e zone.
    3. Seleziona l'immagine di origine di ubuntu-1804-bionic-v20210211
    4. Imposta una dimensione del disco appropriata (consigliati almeno 100 GB).

Figura 2. Crea un disco di avvio Ubuntu.

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

  1. Vai alla console Cloud.
  2. Apri Cloud Shell e usa questo comando: 
    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"
    • Inserisci un nome per l'immagine. Ad esempio, aaos-emulator-image
    • Imposta Zona disco sulla zona in cui hai creato il disco.
    • Imposta il nome del disco sul nome che hai utilizzato per creare il disco.

    Ad 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 maggiori dettagli, vedi Istanza VM di virtualizzazione nidificata.

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

  1. Vai alla console Cloud.
  2. Seleziona il progetto Google Cloud.
  3. Vai a Menu di navigazione > Compute Engine > di un'istanza VM.

    Figura 3. Creare un'istanza VM.

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

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

  1. Vai alla console Cloud.
  2. selezionare il progetto Google Cloud.
  3. Vai a Menu di navigazione > Compute Engine > Istanza VM > Configura la regola firewall.

Installa il software richiesto sulla VM

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

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

  3. Per verificare che la CPU supporti la virtualizzazione hardware (il comando dovrebbe generare un numero diverso da zero): 
    egrep -c '(vmx|svm)' /proc/cpuinfo
  4. Installare la macchina virtuale (KVM) del kernel. Per installare KVM, esegui: 
    sudo apt-get install qemu-kvm libvirt-daemon-system libvirt-clients bridge-utils
  5. Per verificare il funzionamento della KVM: 
    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 container ospitati

  1. Per verificare l'installazione, esegui i container Android Emulator ospitati dal pubblico repository Git. Puoi trovare informazioni dettagliate sui container qui Ora puoi eseguire questi container 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

    In questo modo viene eseguito il pull del container (se non è disponibile localmente) e viene avviato.

  2. All'avvio del container, connettiti al dispositivo configurando ADB nello stesso modo. è come collegare una durata di visualizzazione media su un host locale. Ad esempio: 
    adb connect localhost:5555
adb devices
    L'output dovrebbe essere: 
    List of devices attached
localhost:5555 device

Configurare il servizio di emulatore AAOS

Per configurare il servizio Emulator:

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

    cd android-emulator-container-script
source ./configure.sh
  2. Questa operazione attiva un ambiente virtuale e rende disponibile l'emu-docker eseguibile. Per ottenere informazioni dettagliate sul suo utilizzo, avvialo: 
    emu-docker -h
  3. Per creare i container Docker, accetta i contratti di licenza.
  4. Crea il container 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 di sistema dell'emulatore AAOS. Ad esempio: sdk-repo-linux-system-images-7115454.zip: 
    emu-docker create <emulator-zip> <system-image-zip>
  7. Crea i contenitori web e imposta nome utente e password per l'accesso remoto. 
    ./create_web_container.sh -p user1,passwd1
  8. Avvia il servizio web Emulator AAOS: 
    docker-compose -f js/docker/docker-compose-build.yaml -f js/docker/development.yaml up

Hai avviato un servizio web di emulazione AAOS. Usa il codice seguente per accedere su un browser web:

https://<VM_External__IP>

Risoluzione dei problemi

Se si verifica un errore di connessione all'IP esterno della VM, assicurati che la VM sia configurata per consentire traffico sia HTTP che HTTPS. Per verificarlo, consulta Esecuzione di un server web Apache di base.

Configura il server di turno

Puoi sempre usare il tuo server di turno. Di seguito è riportato un esempio su una VM Google Cloud in esecuzione in un'istanza Compute Engine.

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

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