Cómo compilar tu propio emulador de Cloud

En esta página, se describe cómo ejecutar AAOS Emulator como un servicio web y en un navegador web para que los usuarios puedan acceder a él de forma remota. De esta manera, se proporciona una referencia mínimamente viable de extremo a extremo a través de Compute Engine de Google Cloud. Dicho esto, puedes usar este servicio en cualquier plataforma de nube pública o privada que elijas.

Propósito

Esta configuración centralizada permite que toda una empresa, un proveedor y desarrolladores que trabajan desde casa accedan al emulador de AAOS. De esta manera, la administración y actualización del emulador de AAOS a versiones nuevas es más eficiente y se elimina el tiempo necesario para configurar y administrar máquinas locales para usuarios individuales. Esta solución optimiza el uso de recursos de hardware y habilita un entorno de desarrollo de apps de menor costo. Por ejemplo, para los siguientes fines:

  • Investigación sobre usuarios, revisión de la experiencia del usuario, asistencia al cliente y capacitación.
  • Demostraciones a clientes potenciales y en canales de ventas
  • Prueba, valida y, hasta, depura apps (incluidas las compilaciones diarias de la HMI del OEM) a gran escala. Considera al emulador un sustituto de los bancos de pruebas que se usan para desarrollar apps.
  • Los agentes del centro de atención telefónica de los clientes del OEM tienen una IU de la HU uniforme y de fácil acceso.

Los beneficios de usar el emulador de AAOS son numerosos:

  • Usa una secuencia de comandos de configuración para crear un emulador de AAOS personalizado y basado en la nube (emulador en la nube).
  • Compila una imagen personalizada de AAOS Cloud Emulator para instancias de VM:
    • Configuración lista de un emulador basado en la nube.
    • Imágenes públicas de AVD de AAOS disponibles para el creador del servicio para iniciar un AVD de AAOS con un comando. Por ejemplo, imágenes públicas de AVD de OEM como muestras para que los socios las adapten y apliquen.

Arquitectura

A continuación, se ilustra la arquitectura del ejemplo del emulador de nube. Tu primer servicio mínimamente viable funcionará si agregas tus propias imágenes de AVD del OEM.

Figura 1: Arquitectura de AVD en la nube.

Los componentes básicos del emulador son los siguientes:

aquí.
Artículo Propósito
Android Emulator La instancia del emulador aloja imágenes de AVD
Puente Goldfish-webrtc App para Linux que proporciona comunicación entre la app de React y el emulador de AAOS
android-emulator-webrtc App de React para mostrar la IU de Emulator en un navegador web React también captura los eventos de entrada del usuario y los envía de vuelta al servidor.
Secuencias de comandos de contenedores de Android Emulator Secuencias de comandos de Python para administrar y crear imágenes y contenedores de Docker para los módulos de software anteriores.
Genera tokens para administrar los permisos de acceso del emulador.
Activa el servidor Establece una conexión directa de WebRTC entre el cliente y el servidor. El servidor de turnos solo es necesario cuando el servicio de emulador se ejecuta detrás de firewalls o proxies.
Envoy

Un servicio de proxy para lo siguiente:

  • Proporciona HTTPS con un certificado autofirmado.
  • Redirecciona el tráfico del puerto 80 (HTTP) al puerto 443 (HTTPS).
  • Actúa como un proxy de gRPC para el emulador.
  • Verifica los tokens para permitir el acceso al extremo de gRPC del emulador.
  • Redirecciona otras solicitudes al componente Nginx, que aloja una app de React.

Configura el emulador en una VM en la nube

Para crear un proyecto de GCP, sigue estos pasos:

  1. Ve a la consola de Google Cloud y selecciona un proyecto.
  2. Para confirmar que la facturación está habilitada para tu proyecto de Google Cloud, consulta Habilita, inhabilita o cambia la facturación de un proyecto .
  3. Habilita la API.

Crea una VM de Linux en GCE

1. Habilita la virtualización anidada

De forma predeterminada, la virtualización anidada está habilitada a nivel del proyecto, de la organización o de la carpeta. A menos que alguien de tu organización haya inhabilitado la virtualización anidada, no necesitas hacer nada para habilitarla.

  1. Usa la herramienta de línea de comandos de gcloud para confirmar que se permite la virtualización anidada: 
    gcloud beta resource-manager org-policies describe   \
  constraints/compute.disableNestedVirtualization  --effective --project=[PROJECT_ID]

2. Crea un disco de arranque de Ubuntu-1804-lts

  1. Ve a Cloud Console.
  2. Selecciona el proyecto de GCP.
  3. Ve al menú Navigation y selecciona Compute Engine > Discos > Crear disco.
    1. Proporciona un nombre para el disco. Por ejemplo, ubuntu1804lts
    2. Selecciona una región y una zona. Para admitir la virtualización anidada, asegúrate de que la región y la zona que selecciones admitan procesadores Haswell (o versiones posteriores). Para obtener más información, consulta Regiones y zonas.
    3. Selecciona la imagen de origen de ubuntu-1804-bionic-v20210211.
    4. Establece un tamaño de disco adecuado (se recomienda 100 GB o más).

Figura 2: Crea un disco de arranque de Ubuntu.

3. Crea una imagen personalizada con una clave de licencia especial para habilitar VMX

  1. Ve a la consola de Cloud.
  2. Abre Cloud Shell y usa el siguiente 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"
    • Ingresa un nombre para la imagen. Por ejemplo, aaos-emulator-image
    • Establece la zona del disco en la que creaste el disco.
    • Establece el nombre del disco que usaste para crearlo.

    Por ejemplo:

    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"

Para obtener más información, consulta Instancia de VM de virtualización anidada.

4. Crea una instancia de VM con la imagen personalizada

  1. Ve a Cloud Console.
  2. Selecciona el proyecto de GCP.
  3. Ve a Menú de navegación > Compute Engine > Instancia de VM.

    Figura 3: Crea una instancia de VM.

  4. Ingresa un nombre de instancia. Por ejemplo, aaosemulator
  5. Selecciona la familia y el tipo de máquina que desees. Asegúrate de que la máquina tenga cuatro CPU virtuales y 16 GB de memoria (o más).
  6. Selecciona Intel Cascade Lake (o una versión posterior) como la plataforma de CPU.
  7. Cambia el disco de arranque a la imagen creada en el paso anterior.
  8. Habilita el firewall para lo siguiente:
    • Allow HTTP traffic
    • Allow HTTPS traffic

5. Configura el firewall para abrir los puertos 80 y 443

  1. Ve a Cloud Console.
  2. selecciona el proyecto de GCP.
  3. Ve a Menú de navegación > Compute Engine > Instancia de VM > Configurar regla de firewall.

Instala el software necesario en la VM

  1. Instala Python 3 y Python3-env: 
    sudo apt update
sudo apt install python3
sudo apt-get install python3-venv
  2. Instala el SDK de Android y ADB disponibles en la ruta de acceso. 
    sudo apt install android-sdk

    Para instalar Docker y Docker Compose, consulta Docker y Docker Compose. Asegúrate de poder ejecutarlos como usuario no raíz.

  3. Para confirmar que la CPU admite la virtualización de hardware (el comando debe generar un número distinto de cero), haz lo siguiente: 
    egrep -c '(vmx|svm)' /proc/cpuinfo
  4. Instala la máquina virtual de kernel (KVM). Para instalar KVM, ejecuta lo siguiente: 
    sudo apt-get install qemu-kvm libvirt-daemon-system libvirt-clients bridge-utils
  5. Para verificar que KVM funcione, sigue estos pasos: 
    sudo apt install cpu-checker
kvm-ok
    El resultado debería ser el siguiente: 
    INFO: /dev/kvm exists
KVM acceleration can be used
  6. Para instalar Node.js y Node Packet Manager (NPM), haz lo siguiente: 
    sudo apt install nodejs npm

Inicia los contenedores alojados

  1. Para verificar la instalación, ejecuta los contenedores alojados de Android Emulator desde el repositorio público. Puedes encontrar detalles sobre los contenedores aquí. Ahora puedes ejecutar estos contenedores sin compilarlos. Por ejemplo: 
    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

    Esto extrae el contenedor (si no está disponible de forma local) y lo inicia.

  2. Cuando se inicie el contenedor, configúralo para conectarte al dispositivo con ADB de la misma manera que lo harías para conectar un AVD en un host local. Por ejemplo: 
    adb connect localhost:5555
adb devices
    El resultado debería ser el siguiente: 
    List of devices attached
localhost:5555 device

Configura el servicio de AAOS Emulator

Para configurar el servicio de Emulator, sigue estos pasos:

  1. Instala la secuencia de comandos del contenedor de Docker de Android Emulator: 
    git clone https://github.com/google/android-emulator-container-scripts.git

    cd android-emulator-container-script
source ./configure.sh
  2. Esto activa un entorno virtual y pone a disposición el ejecutable emu-docker. Para obtener información detallada sobre su uso, inícialo: 
    emu-docker -h
  3. Para crear los contenedores de Docker, acepta los contratos de licencia.
  4. Compila el contenedor de Docker del emulador de AAOS.
  5. Descarga una compilación de emulador posterior a la versión 7154743. Por ejemplo: 
    sdk-repo-linux-emulator-7154743.zip
  6. Descarga la imagen del sistema del emulador de AAOS. Por ejemplo, sdk-repo-linux-system-images-7115454.zip: 
    emu-docker create <emulator-zip> <system-image-zip>
  7. Crea los contenedores web y establece el nombre de usuario y la contraseña para el acceso remoto. 
    ./create_web_container.sh -p user1,passwd1
  8. Inicia el servicio web del emulador de AAOS: 
    docker-compose -f js/docker/docker-compose-build.yaml -f js/docker/development.yaml up

Iniciaste correctamente un servicio web de emulador de AAOS. Usa la siguiente información para acceder a él en un navegador web:

https://<VM_External__IP>

Solución de problemas

Si se produce un error de conexión a la IP externa de la VM, asegúrate de que la VM esté configurada para permitir el tráfico HTTP y HTTPS. Para validar esto, consulta Cómo ejecutar un servidor web Apache básico.

Configura el servidor de turnos

Puedes usar tu propio servidor de turnos en cualquier momento. A continuación, se muestra un ejemplo en una instancia de VM de Google Cloud.

Nota: Para que el servidor de TURN funcione en una instancia de VM de Google Cloud, asegúrate de configurar la regla de firewall de la VM para permitir el tráfico en los puertos TCP y UDP 3478 y 3479.

  1. Instala el servidor coturn: 
    sudo apt install coturn
systemctl stop coturn
echo "TURNSERVER_ENABLED=1"|sudo tee -a /etc/default/coturn
  2. Agrega las siguientes líneas para modificar /etc/turnserver.conf: 
    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 el archivo YAML de Docker Compose para incluir la configuración de TURN: 
    cd android-emulator-container-script
nano  js/docker/docker-compose-build.yaml
  4. Agrega las siguientes dos líneas de entorno en la sección del emulador: 
         shm_size: 128M
     expose:
       - "8554"
+    environment:
+       - TURN=printf $SNIPPET
  5. Reinicia el servicio de AAOS Emulator con la configuración de giro. Asegúrate de reemplazar la IP, el nombre de usuario y la credencial del servidor de Turn que se indican a continuación por los tuyos: 
    export SNIPPET="{\"iceServers\":[{\"urls\":\"turn:35.193.52.134:3478\",\"username\":\"test\",\"credential\":\"test123\"}]}"
docker-compose -f js/docker/docker-compose-build.yaml up