Crie seu próprio emulador de nuvem

Este artigo descreve como executar o emulador AAOS 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 isso, você pode usar este serviço em qualquer plataforma de nuvem pública ou privada de sua escolha.

Propósito

Essa configuração e configuração centralizada tornam o AAOS Emulator acessível a toda a empresa, fornecedor e desenvolvedores que trabalham em casa. Isso torna mais eficiente gerenciar e atualizar 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 possibilita um ambiente de desenvolvimento de aplicativos de menor custo. Por exemplo, para fins de:

  • Pesquisa do 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 aplicativos (incluindo compilações de HMI OEM diárias) em escala. Considere o Emulador um substituto para as bancadas de teste usadas para desenvolver aplicativos.
  • Os agentes da central de atendimento ao cliente OEM têm uma interface de usuário de HU uniforme e de fácil acesso.

Os benefícios de usar o Emulador AAOS são inúmeros:

  • 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 AAOS AVD disponíveis para o criador do serviço para iniciar um AAOS AVD com um comando. Por exemplo, imagens públicas de AVD OEM 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 AVD OEM.

Figura 1. Arquitetura do Cloud AVD

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

Item Propósito
Emulador Android A instância do emulador hospeda imagens AVD
Ponte Goldfish-webrtc Aplicativo Linux para fornecer comunicação entre o aplicativo reagir e o emulador AAOS
android-emulator-webrtc Aplicativo React para exibir a interface do usuário 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.
Serviço JWT (serviço JSON Web Token) 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 apenas quando o serviço do emulador 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).
  • Aja 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. Ative a API .

Criar uma VM Linux no GCE

1. Ative a virtualização aninhada

Por padrão, a virtualização aninhada é permitida no nível do projeto, pasta ou organização. A menos que alguém em 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. Vá para o menu de navegação > Compute Engine > Discos > Criar disco.
    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 do ubuntu-1804-bionic-v20210211
    4. Defina um tamanho de disco apropriado (recomenda-se 100 GB ou mais).

Figura 1. Criar disco inicializável do Ubuntu

3. Crie uma imagem personalizada com chave de licença especial para habilitar 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 para a zona na qual você criou o disco.
    • Defina o nome do disco para 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 1. 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. Verifique se a máquina contém quatro vCPUs e 16 GB de memória (ou mais).
  6. Selecione a plataforma de CPU para ser Intel Cascade Lake (ou posterior).
  7. Altere o disco de inicialização para a imagem criada na etapa anterior.
  8. Habilitar 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 o Python 3 e o Python3-env:
    sudo apt update
sudo apt install python3
sudo apt-get install python3-venv
  2. Instale o Android SDK 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 . 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 do Android Emulator hospedados 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 baixa 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

Configurar o serviço do emulador AAOS

Para configurar o serviço Emulador:

  1. Instale o script de contêiner do Android Emulator Docker:
    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 obter informações detalhadas sobre seu uso, execute-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 AAOS.
  5. Baixe uma compilaçã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 o nome de usuário e a senha para acesso remoto.
    ./create_web_container.sh -p user1,passwd1
  8. Inicie o serviço 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 da 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, verifique se a VM está configurada para permitir tráfego HTTP e HTTPS. Para validar isso, consulte Executando um servidor web Apache básico .

Configurar o servidor de turno

Você sempre pode usar seu próprio servidor de turnos. Veja abaixo uma amostra em uma instância de VM do Google Cloud.

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