O Google tem o compromisso de promover a igualdade racial para as comunidades negras. Saiba como.

Construa seu próprio emulador de nuvem

Este artigo descreve como executar AAOS Emulator como um serviço Web e executá-lo em um navegador da web para torná-lo remotamente acessíveis aos usuários. Se o fizer, fornece uma referência end-to-end minimamente viável através 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.

Arquitetura Figura 1. Nuvem 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 Reagir aplicativo para exibir a interface do usuário Emulator em um navegador 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. Ir para o Google Cloud Console e selecionar um projeto .
  2. Para confirmar que a facturação está habilitado para o seu projeto do Google Cloud, consulte ativar, desativar ou alteração de faturamento para 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 tem desativado virtualização aninhada , você não precisa fazer nada para ativá-la.

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

2. Crie um disco inicializável Ubuntu-1804-lts

  1. Ir para Cloud Console .
  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 fonte de ubuntu-1804-bionic-v20210211
    4. Defina um tamanho de disco apropriado (recomenda-se 100 GB ou mais).

Figura 1. Criar Ubuntu disco de inicialização

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

  1. Vá para o Cloud Console .
  2. Abra uma Cloud Shell e use o comando a seguir:
    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 mais detalhes, consulte Nested virtualização VM Instância .

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

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

    Figura 1. Criar um exemplo 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. Ir para Cloud Console .
  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. Instalar Python 3 e Python3-env:
    sudo apt update
    sudo apt install python3
    sudo apt-get install python3-venv
    
  2. Instalar SDK Android e ADB disponível no caminho.
    sudo apt install android-sdk
    

    Para instalar Docker e Docker-Compose, consulte Docker e Docker-compor . Verifique se você pode executar estes como o usuário não-root .

  3. Para confirmar a virtualização de hardware suporta CPU (o comando deve resultar em um número não-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 KVM é trabalhar:
    sudo apt install cpu-checker
    kvm-ok
    
    A saída deve ser:
    INFO: /dev/kvm exists
    KVM acceleration can be used
    
  6. Para instalar Node.js e Nó 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 recipientes 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. Instalar o script recipiente 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 o seu uso, lançá-lo:
    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 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. Comece o AAOS Emulator Web Service:
    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 ao externo IP VM, certifique-se a VM está configurado para permitir o tráfego HTTP e HTTPS. Para validar isso, consulte Executando um servidor web Apache básica .

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.

Nota: Para fazer o trabalho de servidor por sua vez em uma instância do Google Cloud VM, certifique-se de configurar o VM firewall regra 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. Modificar /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. Modificar o arquivo Docker Compose YAML para incluir a configuração VOLTA:
    cd android-emulator-container-script
    nano  js/docker/docker-compose-build.yaml
    
  4. Adicione as seguintes duas linhas de ambiente na secção 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 servidor por sua vez, IP, nome de usuário e credenciais abaixo com o seu próprio:
    export SNIPPET="{\"iceServers\":[{\"urls\":\"turn:35.193.52.134:3478\",\"username\":\"test\",\"credential\":\"test123\"}]}"
    docker-compose -f js/docker/docker-compose-build.yaml up