Criar seu próprio emulador de nuvem

Esta página descreve como executar o AAOS Emulator como um serviço da Web e executá-lo em um navegador da Web para que os usuários possam acessá-los remotamente. Com isso, você tem uma plataforma referência minimamente viável usando o Compute Engine - Dito isso, é possível usar esse serviço em qualquer plataforma de nuvem pública ou privada que você quiser.

Objetivo

Essas configurações centralizadas tornam o AAOS Emulator acessível para toda a empresa, fornecedor e desenvolvedores que trabalham de casa. Isso aumenta a eficiência do gerenciamento e upgrade o 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 uma ambiente de desenvolvimento de apps de baixo custo. Por exemplo, quando:

  • Pesquisa de usuários, análise 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é depure apps em grande escala, incluindo builds diários de HMI do OEM. Considere O emulador é um substituto que os bancos de teste usam para desenvolver apps.
  • Os agentes de call center do cliente OEM têm uma interface HU uniforme e fácil de acessar.

Os benefícios de usar o emulador AAOS são muitos:

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

Arquitetura

A arquitetura do exemplo do emulador na nuvem está ilustrada abaixo. Sua primeira serviço minimamente viável funcionará adicionando suas próprias imagens OEM AVD.

Figura 1. Arquitetura do Cloud AVD.

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

aqui.
Nome Objetivo
Android Emulator A instância do emulador hospeda imagens AVD
Ponte de peixe-dourado-webrtc App Linux para fornecer comunicação entre o app de reação e o emulador AAOS
android-emulator-webrtc (em inglês) React (link em inglês) para mostrar a interface do emulador em uma Web navegador. 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.
Virar servidor Estabelece uma conexão direta WebRTC entre o cliente e o servidor. Virar servidor é necessário apenas quando o serviço do emulador está sendo executado atrás de firewalls ou proxies.
Envoy (em inglês)

Um serviço de proxy para:

  • Fornecer HTTPS usando um certificado autoassinado.
  • Redirecione o tráfego da 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 do gRPC do emulador.
  • Redirecione outras solicitações para o componente Nginx, que hospeda um app React.

Configurar o emulador em uma VM da nuvem

Para criar um projeto do GCP, siga estas etapas:

  1. Acesse o console do Google Cloud e Selecione um projeto.
  2. Para confirmar se o faturamento está ativado para seu 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 virtualização aninhada

Por padrão, a virtualização aninhada é permitida para envolvidos no projeto, na pasta ou na organização. A menos que alguém na organização tenha virtualização aninhada desativada; não é preciso fazer nada para ativá-lo.

  1. Usar a ferramenta de linha de comando gcloud para confirmar que 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-1804-lts

  1. Acessar Console do Cloud:
  2. Selecione o projeto do GCP.
  3. Acesse o menu de navegação e selecione Compute Engine > Discos > Criar disco.
    1. Dê um nome ao 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 selecionada são compatíveis com processadores Haswell (ou posteriores). 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 (recomenda-se 100 GB ou mais).

Figura 2. Criar um disco de inicialização do Ubuntu

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

  1. Acesse o console do Cloud.
  2. Abra o 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 o nome da 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 com o mesmo que você usou 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. Vá para o menu de navegação > Compute Engine > do Compute Engine.

    Figura 3. Criar 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 desejados. A máquina precisa ter quatro vCPUs e 16 GB de memória (ou mais).
  6. Selecione a plataforma de CPU como Intel Cascade Lake (ou posterior).
  7. Altere o disco de inicialização para a imagem criada na etapa anterior.
  8. Ativar 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. Vá para o menu de navegação > Compute Engine > Instância de VM > Configure a 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 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 é possível executar esses usuários como usuário não raiz.

  3. Para confirmar se a CPU oferece suporte à virtualização de hardware (o comando deve resultar em uma número diferente de zero): 
    egrep -c '(vmx|svm)' /proc/cpuinfo
  4. Instale a máquina virtual (KVM) do kernel. 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 será: 
    INFO: /dev/kvm exists
KVM acceleration can be used
  6. Para instalar o Node.js e o Gerenciador de pacotes de nós (NPM, na sigla em inglês): 
    sudo apt install nodejs npm

Iniciar os contêineres hospedados

  1. Para verificar a instalação, execute os contêineres hospedados do Android Emulator no público repositório de dados. Confira detalhes sobre os contêineres aqui. Agora é possível executar esses contêineres sem criá-los. Por 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 extrai o contêiner (se não estiver disponível localmente) e o inicia.

  2. Quando o contêiner for iniciado, configure o adb da mesma maneira para se conectar ao dispositivo como conectar um AVD a um host local. Por exemplo: 
    adb connect localhost:5555
adb devices
    A saída será: 
    List of devices attached
localhost:5555 device

Configurar o serviço AAOS Emulator

Para configurar o serviço do Emulator, siga estas etapas:

  1. Instale o script de contêiner do Docker para o 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 acessar informações detalhadas sobre seu uso, inicie-o: 
    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 emulador do AAOS.
  5. Faça o download de um build do emulador posterior à versão 7154743. Por 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. Criar os contêineres da Web e definir 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 do AAOS. Use o seguinte para acessar 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 tráfego HTTP e HTTPS. Para validar isso, consulte Como executar um servidor da Web Apache básico.

Configurar o servidor de conversão

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

Observação: para que o servidor de conversão funcione em uma instância de VM do Google Cloud, configure a regra de firewall da VM para permitir 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 estas 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 abaixo à seção do emulador: 
         shm_size: 128M
     expose:
       - "8554"
+    environment:
+       - TURN=printf $SNIPPET
  5. Reinicie o serviço AAOS Emulator com a configuração de turno. Lembre-se de substituir o IP, o nome de usuário e a credencial do servidor de conversão 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