Créer votre propre émulateur cloud

Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.

Cette page explique comment exécuter AAOS Emulator en tant que service Web et dans un navigateur Web pour le rendre accessible à distance aux utilisateurs. Vous obtenez ainsi une référence de bout en bout, viable au minimum via Compute Engine Google Cloud. Toutefois, vous pouvez utiliser ce service sur n'importe quelle plate-forme cloud publique ou privée de votre choix.

Objectif

Cette configuration et configuration centralisées rendent AAOS Emulator accessible à l'ensemble d'une entreprise, d'un fournisseur et de développeurs en télétravail. Cela permet de gérer et de mettre à niveau l'émulateur AAOS vers de nouvelles versions plus efficacement, et élimine le temps nécessaire pour configurer et gérer des machines locales pour des utilisateurs individuels. Cette solution optimise l'utilisation des ressources matérielles et permet de créer un environnement de développement d'applications moins coûteux. Par exemple, pour:

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

L'émulateur AAOS présente de nombreux avantages:

• Utilisez un script de configuration pour créer un émulateur AAOS (émulateur cloud) personnalisé et basé sur le cloud.
• Créez une image personnalisée de l'émulateur Cloud AAOS pour les instances de VM :
  • Préparation de la configuration d'un émulateur dans le cloud.
  • Images publiques de l'AVD AAOS disponibles pour le créateur de service afin de démarrer un AVD AAOS avec une commande. Par exemple, des images publiques d'AVD OEM à titre d'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 viable fonctionnera en ajoutant vos propres images AVD OEM.

Figure 1 : Architecture Cloud AVD.

Les principaux composants de l'émulateur sont les suivants:

Configurer l'émulateur sur une VM cloud

Pour créer un projet GCP:

1. Accédez à la console Google Cloud, puis 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. Si aucun utilisateur de votre organisation n'a désactivé la virtualisation imbriquée, aucune action n'est nécessaire pour l'activer.

1. Utilisez l'outil de ligne de commande gcloud pour vérifier que la virtualisation imbriquée est autorisée:

   gcloud beta resource-manager org-policies describe   \
     constraints/compute.disableNestedVirtualization  --effective --project=[PROJECT_ID]
   

2. Créer un disque de démarrage Ubuntu-1804-lts

1. Accédez à la console Cloud.
2. Sélectionnez le projet GCP.
3. Accédez au menu Navigation, puis sélectionnez Compute Engine > Disks > Create Disk (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 sont compatibles avec les processeurs Haswell (ou version ultérieure). Pour en savoir plus, consultez la section Régions et zones.
   3. Sélectionner l'image source de ubuntu-1804-bionic-v20210211
   4. Définissez une taille de disque appropriée (100 Go ou plus est recommandé).

Figure 2. Créez un disque de démarrage Ubuntu.

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

1. Accédez à la console Cloud.
2. Ouvrez Cloud Shell et exécutez 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"
   

   • Saisissez un nom d'image. Par exemple : aaos-emulator-image
   • Définissez "Disk Zone" (Zone de disque) sur la zone dans laquelle vous avez créé le disque.
   • Définissez le nom du disque sur celui que vous avez utilisé pour le créer.

   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 en savoir plus, consultez la section Instance de VM de virtualisation imbriquée.

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

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

   

   Figure 3. Créez une instance de VM.

4. Saisissez 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 Intel Cascade Lake (ou version ultérieure) comme plate-forme de processeur.
7. Remplacez le disque de démarrage par l'image créée à l'étape précédente.
8. Activez le pare-feu pour :
   • Autoriser le trafic HTTP
   • Autoriser le trafic HTTPS

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

1. Accédez à la console Cloud.
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 VM

1. Installez Python 3 et Python3-env:

   sudo apt update
   sudo apt install python3
   sudo apt-get install python3-venv
   

2. Installez le SDK Android et ADB disponibles sur le chemin d'accès.

   sudo apt install android-sdk
   

   Pour installer Docker et Docker-compose, consultez les pages Docker et Docker-compose. Assurez-vous de pouvoir les exécuter en tant qu'utilisateur non racine.

3. Pour vérifier que le processeur est compatible avec la virtualisation matérielle (la commande doit renvoyer un nombre non nul):

   egrep -c '(vmx|svm)' /proc/cpuinfo
   

4. Installez la machine virtuelle Kernel (KVM). Pour installer KVM, exécutez la commande suivante:

   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
   

   Le résultat doit être le suivant:

   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 Android Emulator hébergés à partir du dépôt public. Pour en savoir plus sur les conteneurs, cliquez ici. Vous pouvez désormais exécuter ces conteneurs sans les compiler. 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
   

   Le conteneur est extrait (s'il n'est pas disponible localement) et lancé.

2. Lorsque le conteneur est lancé, connectez-vous à l'appareil en configurant ADB de la même manière que pour connecter un AVD sur un hôte local. Exemple :

   adb connect localhost:5555
   adb devices
   

   Le résultat doit être le suivant:

   List of devices attached
   localhost:5555 device

Configurer le service AAOS Emulator

Pour configurer le service d'émulateur:

1. Installez le script du conteneur Docker Android Emulator:

   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 l'exécutable emu-docker disponible. Pour obtenir des informations détaillées sur son utilisation, lancez-la:

   emu-docker -h
   

3. Pour créer les conteneurs Docker, acceptez les contrats de licence.
4. Créez le conteneur Docker de l'émulateur AAOS.
5. Téléchargez une version de l'émulateur ultérieure à la version 7154743. 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 un nom d'utilisateur et un 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é un service Web AAOS Emulator. Pour y accéder dans un navigateur Web, procédez comme suit:

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 à la fois le trafic HTTP et HTTPS. Pour le vérifier, consultez la section Exécuter un serveur Web Apache basique.

Configurer le serveur TURN

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

Remarque:Pour que le serveur de signalisation fonctionne sur une instance de VM Google Cloud, veillez à configurer la règle de pare-feu de la 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 YAML Docker Compose 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 virage. Veillez à remplacer l'adresse IP, le nom d'utilisateur et les identifiants du serveur TURN 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