Costruisci il tuo emulatore cloud

Questo articolo descrive come eseguire AAOS Emulator come servizio Web ed eseguirlo in un browser Web per renderlo accessibile in remoto agli utenti. In questo modo si fornisce un riferimento end-to-end minimamente praticabile 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 impostazione centralizzate rendono l'emulatore AAOS accessibile a un'intera azienda, fornitore e sviluppatori che lavorano da casa. Ciò rende più efficiente la gestione e l'aggiornamento dell'emulatore AAOS a nuove versioni ed elimina il tempo necessario per impostare 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 costi inferiori. Ad esempio, ai fini di:

  • Ricerca sugli utenti, revisione dell'esperienza utente, assistenza clienti e formazione.
  • Demo ai potenziali clienti e nei canali di vendita.
  • Testa, convalida e persino esegui il debug delle app (incluse le build HMI OEM giornaliere) su vasta scala. Considera l'emulatore un sostituto dei banchi di prova utilizzati per sviluppare app.
  • Gli agenti del call center dei clienti OEM dispongono di un'interfaccia utente HU uniforme e di facile accesso.

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

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

Architettura

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

Figura 1. Architettura AVD cloud

Gli elementi chiave dell'emulatore sono:

Qui .
Articolo 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-androide-webrtc Applicazione React per visualizzare l'interfaccia utente dell'emulatore in un browser Web. React cattura 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.
Genera token per gestire i permessi di accesso dell'emulatore.
Trasforma il server Stabilisce una connessione diretta WebRTC tra il client e il server. L'attivazione del server è necessaria solo quando il servizio emulatore è in esecuzione dietro firewall o proxy.
Inviato

Un servizio proxy per:

  • Fornire HTTPS utilizzando un certificato autofirmato.
  • Reindirizzare il traffico dalla porta 80 (http) alla porta 443 (https).
  • Agire come proxy gRPC per l'emulatore.
  • Verificare 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 VM cloud

Per creare un progetto GCP:

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

Crea una VM 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. Utilizza lo strumento da riga di comando gcloud per verificare che la virtualizzazione annidata sia 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. Fornire 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 selezionate supportino i processori Haswell (o successivi). Per saperne di più, consulta Regioni e zone .
    3. Seleziona l'immagine sorgente di ubuntu-1804-bionic-v20210211
    4. Imposta una dimensione del disco appropriata (si consigliano 100 GB o più).

Figura 1. Creazione del disco di avvio di Ubuntu

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

  1. Vai alla Console Cloud .
  2. Apri Cloud Shell e utilizza 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"
    
    • Inserisci un nome per l'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 maggiori dettagli, consulta Istanza VM di virtualizzazione nidificata .

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

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

    Figura 1. Creazione di un'istanza VM

  4. Inserisci un nome di istanza. Ad esempio, aaosemulator
  5. Selezionare la famiglia e il tipo di macchina desiderata. Assicurati che la macchina contenga quattro vCPU e 16 GB di memoria (o più).
  6. Selezionare la piattaforma CPU che sia Intel Cascade Lake (o successiva).
  7. Sostituisci 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. seleziona il progetto GCP.
  3. Vai al menu di navigazione > Compute Engine > Istanza VM > Configura 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 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 restituire 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, eseguire i contenitori dell'emulatore Android ospitati 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 abbassa il contenitore (se non è disponibile localmente) e lo avvia.

  2. Quando il contenitore viene avviato, connettiti al dispositivo configurando ADB nello stesso modo in cui colleghi 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 di emulazione AAOS

Per impostare 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, avviatelo:
    emu-docker -h
    
  3. Per creare i contenitori Docker, accettare 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 di emulazione 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. Avviare 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 di emulazione 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 VM, assicurati che la VM sia configurata per consentire sia il traffico HTTP che HTTPS. Per convalidare ciò, vedere Esecuzione di un server Web Apache di base .

Configura il server di turno

Puoi sempre utilizzare il tuo server di turno. Di seguito viene fornito un esempio su un'istanza VM di Google Cloud.

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

  1. Installa 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 YAML di Docker Compose 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. Riavviare il servizio AAOS Emulator con la configurazione del turno. Assicurati di sostituire l'IP del server di turno, il nome utente e le credenziali 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