Crie 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 torná-lo acessível remotamente aos usuários. Isso fornece uma referência completa e minimamente viável por meio do Google Cloud Compute Engine . Dito isto, você pode usar este serviço em qualquer plataforma de nuvem pública ou privada de sua escolha.

Propósito

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

  • Pesquisa do usuário, análise da experiência do usuário, suporte ao cliente e treinamento.
  • Demonstrações para clientes potenciais e em canais de vendas.
  • Teste, valide e até mesmo depure aplicativos (incluindo compilações diárias de IHM OEM) em escala. Considere o emulador um substituto para os bancos de testes usados ​​para desenvolver aplicativos.
  • Os agentes de call center de clientes OEM têm uma interface de usuário HU uniforme e fácil de acessar.

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

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

Arquitetura

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

Figura 1. Arquitetura Cloud AVD.

Os principais blocos de construção do emulador são:

aqui .
Item Propósito
Emulador Android A instância do emulador hospeda imagens AVD
Ponte peixinho-webrtc Aplicativo Linux para fornecer comunicação entre o aplicativo react e o emulador AAOS
emulador-android-webrtc Aplicativo React para exibir a IU 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 emulador Android Scripts Python para gerenciar e criar imagens e contêineres 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. Turn server é necessário somente quando o serviço Emulator está sendo executado atrás de firewalls ou proxies.
Enviado

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.
  • Redirecione outras solicitações para o componente Nginx, que hospeda um aplicativo 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 seu projeto do Google Cloud, consulte Ativar, desativar ou alterar o faturamento de um projeto .
  3. Habilite a API .

Crie uma VM Linux no GCE

1. Habilite 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 desabilitado a virtualização aninhada , você não precisa fazer nada para habilitá-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. Crie um disco inicializável Ubuntu-1804-lts

  1. Acesse o Console do Cloud .
  2. Selecione o projeto do GCP.
  3. Acesse o menu de navegação e selecione Compute Engine > Disks > Create Disk .
    1. Forneça um nome de disco. Por exemplo, ubuntu1804lts
    2. Selecione uma região e zona. Para oferecer suporte à virtualização aninhada, certifique-se de que a região e a zona selecionadas sejam 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 apropriado (recomenda-se 100 GB ou maior).

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

3. Crie uma imagem personalizada com 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 Disk Zone como a zona na qual você criou o disco.
    • Defina o nome do disco com o nome que você usou para criar o disco.

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

4. Crie 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 desejados. Certifique-se de que a máquina contenha 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. Habilite o Firewall para:
    • Permitir tráfego HTTP
    • Permitir tráfego HTTPS

5. Configure 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.

Instale o software necessário na VM

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

    Para instalar o Docker e o Docker-compose, consulte Docker e Docker-compose . Certifique-se de poder executá-los como usuário não root .

  3. Para confirmar se a CPU suporta virtualização de hardware (o comando deve 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 o KVM, execute:
    sudo apt-get install qemu-kvm libvirt-daemon-system libvirt-clients bridge-utils
  5. Para verificar se o KVM está funcionando:
    sudo apt install cpu-checker
kvm-ok
    A saída deve 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

Inicie os contêineres hospedados

  1. Para verificar a instalação, execute os contêineres hospedados do Android Emulator no repositório público. Você pode encontrar detalhes sobre os contêineres aqui . Agora você pode executar esses contêineres sem construí-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 desce o contêiner (se 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 conecta um AVD em um host local. Por exemplo:
    adb connect localhost:5555
adb devices
    A saída deve ser:
    List of devices attached
localhost:5555 device

Configure o serviço AAOS Emulator

Para configurar o serviço do emulador:

  1. Instale o script de contêiner 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 executável emu-docker. Para obter informações detalhadas sobre seu uso, inicie-o:
    emu-docker -h
  3. Para criar os contêineres Docker, aceite os contratos de licença.
  4. Crie o contêiner Docker do emulador AAOS.
  5. Baixe uma versão do emulador posterior à versão 7154743. Por exemplo:
    sdk-repo-linux-emulator-7154743.zip
  6. Baixe a 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 Web Containers e defina nome de usuário e 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 com sucesso um serviço Web do emulador AAOS! Use o seguinte para acessá-lo 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, certifique-se de que a VM esteja configurada para permitir tráfego HTTP e HTTPS. Para validar isso, consulte Executando um servidor web Apache básico .

Configure o servidor de turno

Você sempre pode usar seu próprio servidor de turno. Abaixo está um exemplo de uma instância de VM do Google Cloud.

Observação: para fazer o servidor turn funcionar 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 AAOS Emulator com a configuração turn. Certifique-se de substituir o IP, nome de usuário e credencial do servidor 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