Construisez votre propre émulateur cloud

Cet article décrit comment exécuter AAOS Emulator en tant que service Web et l'exécuter dans un navigateur Web pour le rendre accessible à distance aux utilisateurs. Cela fournit une référence de bout en bout minimalement viable via Google Cloud Compute Engine . Cela dit, vous pouvez utiliser ce service sur n'importe quelle plateforme cloud publique ou privée de votre choix.

But

Cette configuration et cette configuration centralisées rendent l'émulateur AAOS accessible à l'ensemble de l'entreprise, du fournisseur et des développeurs travaillant à domicile. Cela rend plus efficace la gestion et la mise à niveau de l'émulateur AAOS vers de nouvelles versions et élimine le temps nécessaire pour configurer et gérer les machines locales pour les utilisateurs individuels. Cette solution optimise l'utilisation des ressources matérielles et permet un environnement de développement d'applications à moindre coût. Par exemple, aux fins de :

  • Recherche d'utilisateurs, examen de l'expérience utilisateur, support client et formation.
  • Démos aux clients potentiels et dans les canaux de vente.
  • Testez, validez et même déboguez des applications (y compris les versions quotidiennes d'IHM OEM) à grande échelle. Considérez l'émulateur comme un substitut aux bancs de test utilisés pour développer des applications.
  • Les agents des centres d'appels clients OEM disposent d'une interface utilisateur HU uniforme et facile d'accès.

Les avantages de l'utilisation de l'émulateur AAOS sont nombreux :

  • Utilisez un script de configuration pour créer un émulateur AAOS personnalisé et basé sur le cloud (émulateur cloud).
  • Créez une image AAOS Cloud Emulator personnalisée pour les instances de VM :
    • Configuration prête d'un émulateur basé sur le cloud.
    • Images AVD AAOS publiques disponibles pour le créateur du service pour démarrer un AVD AAOS avec une commande. Par exemple, des images AVD OEM publiques comme exemples que les partenaires peuvent adapter et appliquer.

Architecture

L'architecture de l'exemple d'émulateur cloud est illustrée ci-dessous. Votre premier service minimalement viable fonctionnera en ajoutant vos propres images AVD OEM.

Figure 1. Architecture cloud AVD

Les principaux blocs de construction de l'émulateur sont :

ici .
Article But
Émulateur Android L'instance d'émulateur héberge des images AVD
Pont Goldfish-webrtc Application Linux pour assurer la communication entre l'application React et l'émulateur AAOS
android-emulator-webrtc Application React pour afficher l'interface utilisateur de l'émulateur dans un navigateur Web. React capture également les événements d'entrée de l'utilisateur et les renvoie au serveur.
Scripts de conteneur d'émulateur Android Scripts Python pour gérer et créer des images Docker et des conteneurs pour les modules logiciels ci-dessus.
Génère des jetons pour gérer les autorisations d'accès de l'émulateur.
Tourner le serveur Établit une connexion directe WebRTC entre le client et le serveur. L'activation du serveur n'est requise que lorsque le service Emulator s'exécute derrière des pare-feu ou des proxys.
Envoyé

Un service proxy pour :

  • Fournissez HTTPS à l'aide d'un certificat auto-signé.
  • Redirigez le trafic sur le port 80 (http) vers le port 443 (https).
  • Agir en tant que proxy gRPC pour l'émulateur.
  • Vérifiez les jetons pour autoriser l'accès au point de terminaison gRPC de l'émulateur.
  • Redirigez les autres requêtes vers le composant Nginx, qui héberge une application React.

Configurer un émulateur sur une VM cloud

Pour créer un projet GCP :

  1. Accédez à Google Cloud Console et sélectionnez un projet .
  2. Pour vérifier que la facturation est activée pour votre projet Google Cloud, consultez Activer, désactiver ou modifier la facturation pour un projet .
  3. Activez l'API .

Créer une VM Linux dans GCE

1. Activer la virtualisation imbriquée

Par défaut, la virtualisation imbriquée est autorisée au niveau du projet, du dossier ou de l'organisation. À moins qu'un membre de votre organisation n'ait désactivé la virtualisation imbriquée , vous n'avez rien à faire pour l'activer.

  1. Utilisez l' outil de ligne de commande gcloud pour confirmer que la virtualisation imbriquée est autorisée :
    gcloud beta resource-manager org-policies describe   \
  constraints/compute.disableNestedVirtualization  --effective --project=[PROJECT_ID]

2. Créez un disque amorçable Ubuntu-1804-lts

  1. Accédez à Cloud Console .
  2. Sélectionnez le projet GCP.
  3. Accédez au menu de navigation > Compute Engine > Disques > Créer un disque.
    1. Indiquez un nom de disque. Par exemple, ubuntu1804lts
    2. Sélectionnez une région et une zone. Pour prendre en charge la virtualisation imbriquée, assurez-vous que la région et la zone que vous sélectionnez prennent en charge les processeurs Haswell (ou ultérieurs). Pour en savoir plus, consultez Régions et zones .
    3. Sélectionnez l'image source de ubuntu-1804-bionic-v20210211
    4. Définissez une taille de disque appropriée (100 Go ou plus est recommandé).

Figure 1. Créer un disque amorçable Ubuntu

3. Créez une image personnalisée avec une clé de licence spéciale pour activer VMX

  1. Accédez à Cloud Console .
  2. Ouvrez un Cloud Shell et utilisez la commande suivante :
    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"
    • Entrez un nom d'image. Par exemple, aaos-emulator-image
    • Définissez Disk Zone sur la zone dans laquelle vous avez créé le disque.
    • Définissez le nom du disque sur le nom que vous avez utilisé pour créer le disque.

    Par exemple:

    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"

Pour plus d'informations, consultez Instance de VM de virtualisation imbriquée .

4. Créez une instance de VM à l'aide de l'image personnalisée

  1. Accédez à Cloud Console .
  2. Sélectionnez le projet GCP.
  3. Accédez au menu de navigation > Compute Engine > Instance de VM.

    Figure 1. Créer une instance de VM

  4. Entrez un nom d'instance. Par exemple, aaosemulator
  5. Sélectionnez la famille et le type de machine souhaités. Assurez-vous que la machine contient quatre vCPU et 16 Go de mémoire (ou plus).
  6. Sélectionnez la plate-forme du processeur pour qu'elle soit Intel Cascade Lake (ou une version ultérieure).
  7. Remplacez le disque de démarrage par l'image créée à l'étape précédente.
  8. Activer le pare-feu pour :
    • Autoriser le trafic HTTP
    • Autoriser le trafic HTTPS

5. Configurez le pare-feu pour ouvrir les ports 80 et 443

  1. Accédez à Cloud Console .
  2. sélectionnez le projet GCP.
  3. Accédez au menu de navigation > Compute Engine > Instance de VM > Configurer une règle de pare-feu.

Installer le logiciel requis sur la machine virtuelle

  1. Installez Python 3 et Python3-env :
    sudo apt update
sudo apt install python3
sudo apt-get install python3-venv
  2. Installez Android SDK et ADB disponibles sur le chemin.
    sudo apt install android-sdk

    Pour installer Docker et Docker-compose, consultez Docker et Docker-compose . Assurez-vous que vous pouvez les exécuter en tant qu'utilisateur non root .

  3. Pour confirmer que le processeur prend en charge la virtualisation matérielle (la commande doit donner un nombre différent de zéro) :
    egrep -c '(vmx|svm)' /proc/cpuinfo
  4. Installez la machine virtuelle du noyau (KVM). Pour installer KVM, exécutez :
    sudo apt-get install qemu-kvm libvirt-daemon-system libvirt-clients bridge-utils
  5. Pour vérifier que KVM fonctionne :
    sudo apt install cpu-checker
kvm-ok
    La sortie doit être :
    INFO: /dev/kvm exists
KVM acceleration can be used
  6. Pour installer Node.js et Node Packet Manager (NPM) :
    sudo apt install nodejs npm

Démarrer les conteneurs hébergés

  1. Pour vérifier l'installation, exécutez les conteneurs hébergés de l'émulateur Android à partir du référentiel public. Vous pouvez trouver des détails sur les conteneurs ici . Vous pouvez désormais exécuter ces conteneurs sans les créer. Par exemple :
    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

    Cela déroule le conteneur (s'il n'est pas disponible localement) et le lance.

  2. Lorsque le conteneur est lancé, connectez-vous à l'appareil en configurant ADB de la même manière que la connexion d'un AVD sur un hôte local. Par exemple :
    adb connect localhost:5555
adb devices
    Le résultat doit être :
    List of devices attached
localhost:5555 device

Configurer le service d'émulateur AAOS

Pour configurer le service Emulator :

  1. Installez le script de conteneur Docker de l'émulateur Android :
    git clone https://github.com/google/android-emulator-container-scripts.git

    cd android-emulator-container-script
source ./configure.sh
  2. Cela active un environnement virtuel et rend disponible l'exécutable emu-docker. Pour obtenir des informations détaillées sur son utilisation, lancez-le :
    emu-docker -h
  3. Pour créer les conteneurs Docker, acceptez les contrats de licence.
  4. Créez le conteneur AAOS Emulator Docker.
  5. Téléchargez une version d'émulateur ultérieure à la version 7154743. Par exemple :
    sdk-repo-linux-emulator-7154743.zip
  6. Téléchargez l'image système de l'émulateur AAOS. Par exemple, sdk-repo-linux-system-images-7115454.zip :
    emu-docker create <emulator-zip> <system-image-zip>
  7. Créez les conteneurs Web et définissez le nom d'utilisateur et le mot de passe pour l'accès à distance.
    ./create_web_container.sh -p user1,passwd1
  8. Démarrez le service Web de l'émulateur AAOS :
    docker-compose -f js/docker/docker-compose-build.yaml -f js/docker/development.yaml up

Vous avez démarré avec succès un service Web d'émulateur AAOS ! Utilisez ce qui suit pour y accéder sur un navigateur Web :

https://<VM_External__IP>

Dépannage

Si une erreur de connexion à l'adresse IP externe de la VM se produit, assurez-vous que la VM est configurée pour autoriser le trafic HTTP et HTTPS. Pour valider cela, consultez Exécution d'un serveur Web Apache de base .

Configurer le serveur tournant

Vous pouvez toujours utiliser votre propre serveur de tour. Vous trouverez ci-dessous un exemple sur une instance de VM Google Cloud.

Remarque : Pour que le serveur Turn fonctionne sur une instance de VM Google Cloud, veillez à configurer la règle de pare-feu de VM pour autoriser le trafic sur les ports TCP et UDP 3478 et 3479.

  1. Installez le serveur coturn :
    sudo apt install coturn
systemctl stop coturn
echo "TURNSERVER_ENABLED=1"|sudo tee -a /etc/default/coturn
  2. Modifiez /etc/turnserver.conf en ajoutant les lignes suivantes :
    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. Modifiez le fichier Docker Compose YAML pour inclure la configuration TURN :
    cd android-emulator-container-script
nano  js/docker/docker-compose-build.yaml
  4. Ajoutez les deux lignes d'environnement suivantes dans la section de l'émulateur :
         shm_size: 128M
     expose:
       - "8554"
+    environment:
+       - TURN=printf $SNIPPET
  5. Redémarrez le service AAOS Emulator avec la configuration de tour. Assurez-vous de remplacer l'adresse IP, le nom d'utilisateur et les informations d'identification du serveur tournant ci-dessous par les vôtres :
    export SNIPPET="{\"iceServers\":[{\"urls\":\"turn:35.193.52.134:3478\",\"username\":\"test\",\"credential\":\"test123\"}]}"
docker-compose -f js/docker/docker-compose-build.yaml up