Criar seu próprio emulador de nuvem

Esta página descreve como executar o AAOS Emulator como um serviço da Web e em um navegador da Web para torná-lo acessível remotamente aos usuários. Isso fornece uma referência mínima viável de ponta a ponta pelo Compute Engine do Google Cloud. No entanto, você pode usar esse serviço em qualquer plataforma de nuvem pública ou privada que preferir.

Objetivo

Essa configuração centralizada torna o AAOS Emulator acessível para toda a empresa, fornecedor e desenvolvedores que trabalham de casa. Isso torna mais eficiente o gerenciamento e o upgrade do emulador AAOS para novas versões e elimina o tempo necessário para configurar e gerenciar máquinas locais para usuários individuais. Essa solução otimiza o uso de recursos de hardware e permite um ambiente de desenvolvimento de apps com custo mais baixo. Por exemplo, para fins de:

  • Pesquisa de usuário, revisão da experiência do usuário, suporte ao cliente e treinamento.
  • Demonstrações para clientes em potencial e em canais de vendas.
  • Teste, valide e até mesmo depure apps (incluindo builds diários de HMI de OEM) em grande escala. Considere que o emulador é um substituto dos bancos de testes usados para desenvolver apps.
  • Os agentes do call center de atendimento ao cliente do OEM têm uma interface uniforme e fácil de acessar.

Os benefícios do uso do AAOS Emulator são numerosos:

  • Use um script de configuração para criar um emulador AAOS personalizado e baseado na nuvem.
  • Crie uma imagem personalizada do AAOS Cloud Emulator para instâncias de VM:
    • Configuração pronta de um emulador baseado na nuvem.
    • Imagens públicas de AVD do AAOS disponíveis para o criador de serviços para iniciar um AVD do AAOS com um comando. Por exemplo, imagens públicas de AVDs OEM como amostras para os parceiros adaptarem e aplicarem.

Arquitetura

A arquitetura do exemplo de emulador de nuvem é ilustrada abaixo. Seu primeiro serviço minimamente viável vai funcionar adicionando suas próprias imagens de AVD do OEM.

Figura 1. Arquitetura de AVDs da nuvem.

Os principais elementos básicos do emulador são:

aqui.
Nome Objetivo
Android Emulator A instância do emulador hospeda imagens do AVD
Ponte Goldfish-WebRTC App Linux para fornecer comunicação entre o app React e o emulador AAOS
android-emulator-webrtc App React para mostrar a interface do emulador em um navegador da Web. O React também captura eventos de entrada do usuário e os envia de volta ao servidor.
Scripts de contêiner do Android Emulator Scripts Python para gerenciar e criar imagens e contêineres do Docker para os módulos de software acima.
Gera tokens para gerenciar as permissões de acesso do emulador.
Servidor de giro Estabelece uma conexão direta do WebRTC entre o cliente e o servidor. O servidor de turnos é necessário apenas quando o serviço do emulador está em execução por firewalls ou proxies.
Envoy

Um serviço de proxy para:

  • Forneça HTTPS usando um certificado autoassinado.
  • Redirecione o tráfego na porta 80 (http) para a porta 443 (https).
  • Atuar como um proxy gRPC para o emulador.
  • Verifique os tokens para permitir o acesso ao endpoint gRPC do emulador.
  • Redirecionar outras solicitações para o componente Nginx, que hospeda um app React.

Configurar o emulador em uma VM na nuvem

Para criar um projeto do GCP:

  1. Acesse o console do Google Cloud e selecione um projeto.
  2. Para confirmar se o faturamento está ativado para o projeto do Google Cloud, consulte Ativar, desativar ou alterar o faturamento de um projeto .
  3. Ative a API.

Criar uma VM do Linux no GCE

1. Ativar a virtualização aninhada

Por padrão, a virtualização aninhada é permitida no nível do projeto, da pasta ou da organização. A menos que alguém na sua organização tenha desativado a virtualização aninhada, você não precisa fazer nada para ativá-la.

  1. Use a ferramenta de linha de comando gcloud para confirmar se a virtualização aninhada é permitida: 
    gcloud beta resource-manager org-policies describe   \
  constraints/compute.disableNestedVirtualization  --effective --project=[PROJECT_ID]

2. Criar um disco inicializável do Ubuntu-18.04-lts

  1. Acesse o console do Cloud.
  2. Selecione o projeto do GCP.
  3. Acesse o menu Navigation e selecione Compute Engine > Disks > Create Disk.
    1. Insira um nome para o disco. Por exemplo, ubuntu1804lts
    2. Selecione uma região e uma zona. Para oferecer suporte à virtualização aninhada, verifique se a região e a zona selecionadas oferecem suporte a processadores Haswell (ou mais recentes). Para saber mais, consulte Regiões e zonas.
    3. Selecione a imagem de origem de ubuntu-1804-bionic-v20210211
    4. Defina um tamanho de disco adequado (recomendamos 100 GB ou mais).

Figura 2. Crie um disco inicializável do Ubuntu.

3. Criar uma imagem personalizada com uma chave de licença especial para ativar o VMX

  1. Acesse o Console do Cloud.
  2. Abra um Cloud Shell e use o seguinte 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"
    • Insira um nome de imagem. Por exemplo, aaos-emulator-image
    • Defina a zona do disco como a zona em que você criou o disco.
    • Defina o nome do disco como o nome usado para criá-lo.

    Exemplo:

    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 mais detalhes, consulte Instância de VM de virtualização aninhada.

4. Criar uma instância de VM usando a imagem personalizada

  1. Acesse o console do Cloud.
  2. Selecione o projeto do GCP.
  3. Acesse Menu de navegação > Compute Engine > Instância de VM.

    Figura 3. Crie uma instância de VM.

  4. Insira um nome de instância. Por exemplo, aaosemulator
  5. Selecione a família e o tipo de máquina. Verifique se a máquina contém quatro vCPUs e 16 GB de memória (ou mais).
  6. Selecione a plataforma de CPU como Intel Cascade Lake (ou mais recente).
  7. Mude o disco de inicialização para a imagem criada na etapa anterior.
  8. Ative o firewall para:
    • Permitir tráfego HTTP
    • Permitir tráfego HTTPS

5. Configurar o firewall para abrir as portas 80 e 443

  1. Acesse o console do Cloud.
  2. selecione o projeto do GCP.
  3. Acesse Menu de navegação > Compute Engine > Instância de VM > Configurar regra de firewall.

Instalar o software necessário na VM

  1. Instale o Python 3 e o Python3-env: 
    sudo apt update
sudo apt install python3
sudo apt-get install python3-venv
  2. Instale o SDK do Android e o ADB disponíveis no caminho. 
    sudo apt install android-sdk

    Para instalar o Docker e o Docker-compose, consulte Docker e Docker-compose. Verifique se você pode executar esses comandos como usuário não raiz.

  3. Para confirmar se a CPU oferece suporte à virtualização de hardware (o comando precisa resultar em um número diferente de zero): 
    egrep -c '(vmx|svm)' /proc/cpuinfo
  4. Instale a máquina virtual do kernel (KVM). Para instalar a KVM, execute: 
    sudo apt-get install qemu-kvm libvirt-daemon-system libvirt-clients bridge-utils
  5. Para verificar se a KVM está funcionando: 
    sudo apt install cpu-checker
kvm-ok
    A saída precisa ser: 
    INFO: /dev/kvm exists
KVM acceleration can be used
  6. Para instalar o Node.js e o Node Packet Manager (NPM): 
    sudo apt install nodejs npm

Iniciar os contêineres hospedados

  1. Para verificar a instalação, execute os contêineres do Android Emulator hospedados no repositório público. Confira os detalhes dos contêineres aqui. Agora você pode executar esses contêineres sem criá-los. Exemplo: 
    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

    Isso puxa o contêiner (se ele não estiver disponível localmente) e o inicia.

  2. Quando o contêiner for iniciado, conecte-se ao dispositivo configurando o ADB da mesma forma que conectar um AVD em um host local. Exemplo: 
    adb connect localhost:5555
adb devices
    A saída precisa ser: 
    List of devices attached
localhost:5555 device

Configurar o serviço do emulador AAOS

Para configurar o serviço do emulador:

  1. Instale o script do contêiner do Docker do Android Emulator: 
    git clone https://github.com/google/android-emulator-container-scripts.git

    cd android-emulator-container-script
source ./configure.sh
  2. Isso ativa um ambiente virtual e disponibiliza o emu-docker executável. Para conferir informações detalhadas sobre o uso, inicie o aplicativo: 
    emu-docker -h
  3. Para criar os contêineres do Docker, aceite os contratos de licença.
  4. Crie o contêiner do Docker do AAOS Emulator.
  5. Faça o download de um build do emulador mais recente que a versão 7154743. Exemplo: 
    sdk-repo-linux-emulator-7154743.zip
  6. Faça o download da imagem do sistema do emulador AAOS. Por exemplo, sdk-repo-linux-system-images-7115454.zip: 
    emu-docker create <emulator-zip> <system-image-zip>
  7. Crie os contêineres da Web e defina o nome de usuário e a senha para acesso remoto. 
    ./create_web_container.sh -p user1,passwd1
  8. Inicie o serviço da Web do emulador AAOS: 
    docker-compose -f js/docker/docker-compose-build.yaml -f js/docker/development.yaml up

Você iniciou um serviço da Web do emulador AAOS. Use as seguintes instruções para acessar o app em um navegador da Web:

https://<VM_External__IP>

Solução de problemas

Se ocorrer um erro de conexão com o IP externo da VM, verifique se a VM está configurada para permitir tráfego HTTP e HTTPS. Para validar isso, consulte Como executar um servidor da Web Apache básico.

Configurar o servidor de turnos

Você pode usar seu próprio servidor de turnos. Confira abaixo um exemplo de uma instância de VM do Google Cloud.

Observação:para que o servidor de turno funcione em uma instância de VM do Google Cloud, configure a regra de firewall da VM para permitir o tráfego nas portas TCP e UDP 3478 e 3479.

  1. Instale o servidor coturn: 
    sudo apt install coturn
systemctl stop coturn
echo "TURNSERVER_ENABLED=1"|sudo tee -a /etc/default/coturn
  2. Modifique /etc/turnserver.conf adicionando as seguintes linhas: 
    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. Modifique o arquivo YAML do Docker Compose para incluir a configuração TURN: 
    cd android-emulator-container-script
nano  js/docker/docker-compose-build.yaml
  4. Adicione as duas linhas de ambiente a seguir na seção do emulador: 
         shm_size: 128M
     expose:
       - "8554"
+    environment:
+       - TURN=printf $SNIPPET
  5. Reinicie o serviço do emulador AAOS com a configuração de turno. Substitua o IP, o nome de usuário e a credencial do servidor de turn abaixo pelos seus: 
    export SNIPPET="{\"iceServers\":[{\"urls\":\"turn:35.193.52.134:3478\",\"username\":\"test\",\"credential\":\"test123\"}]}"
docker-compose -f js/docker/docker-compose-build.yaml up