Ab dem 27. März 2025 empfehlen wir, android-latest-release anstelle von aosp-main zu verwenden, um AOSP zu erstellen und Beiträge dazu zu leisten. Weitere Informationen finden Sie unter Änderungen am AOSP.

Diese Seite wurde von der Cloud Translation API übersetzt.

Eigenen Cloud-Emulator erstellen

Auf dieser Seite wird beschrieben, wie Sie den AAOS-Emulator als Webdienst und in einem Webbrowser ausführen, um Nutzern den Remotezugriff zu ermöglichen. So erhalten Sie eine End-to-End-Minimal Viable Reference über die Compute Engine von Google Cloud. Sie können diesen Dienst jedoch auf einer beliebigen öffentlichen oder privaten Cloud-Plattform Ihrer Wahl verwenden.

Zweck

Durch diese zentrale Konfiguration und Einrichtung ist der AAOS-Emulator für ein ganzes Unternehmen, Lieferanten und Entwickler im Homeoffice zugänglich. Dadurch lässt sich der AAOS-Emulator effizienter verwalten und auf neue Versionen aktualisieren. Außerdem müssen keine lokalen Maschinen mehr für einzelne Nutzer eingerichtet und verwaltet werden. Diese Lösung optimiert die Nutzung von Hardwareressourcen und ermöglicht eine kostengünstigere App-Entwicklungsumgebung. Beispielsweise für folgende Zwecke:

Nutzerstudien, Überprüfung der Nutzerfreundlichkeit, Kundensupport und Schulungen.
Demos für potenzielle Kunden und in Vertriebskanälen
Apps (einschließlich täglicher OEM-HMI-Builds) im großen Maßstab testen, validieren und sogar debuggen. Der Emulator ist ein Ersatz für die Testbänke, die zur Entwicklung von Apps verwendet werden.
Kundenservicemitarbeiter von OEMs haben eine einheitliche, leicht zugängliche HU-Benutzeroberfläche.

Der AAOS-Emulator bietet zahlreiche Vorteile:

Mit einem Einrichtungsskript einen benutzerdefinierten und cloudbasierten AAOS-Emulator (Cloud-Emulator) erstellen
Benutzerdefiniertes AAOS Cloud Emulator-Image für VM-Instanzen erstellen:
- Einrichten eines cloudbasierten Emulators
- Öffentliche AAOS-AVD-Images, die dem Dienstersteller zur Verfügung stehen, um eine AAOS-AVD mit einem Befehl zu starten. Beispielsweise öffentliche AVD-Images von OEMs als Musterbeispiele, die Partner anpassen und anwenden können.

Architektur

Die Architektur des Beispiels für einen Cloud-Emulator ist unten dargestellt. Ihr erster minimal funktionsfähiger Dienst funktioniert, wenn Sie Ihre eigenen OEM-AVD-Images hinzufügen.

Abbildung 1: Cloud AVD-Architektur.

Die wichtigsten Emulatorbausteine sind:

finden Sie hier.

Artikel	Zweck
Android-Emulator	Emulatorinstanz hostet AVD-Images
Goldfish-WebRTC-Brücke	Linux-App für die Kommunikation zwischen der React-App und dem AAOS-Emulator
android-emulator-webrtc	React-App, um die Emulator-Benutzeroberfläche in einem Webbrowser anzuzeigen React erfasst auch Nutzereingabeereignisse und sendet sie an den Server zurück.
Android Emulator-Containerscripts	Python-Scripts zum Verwalten und Erstellen von Docker-Images und ‑Containern für die oben genannten Softwaremodule.
Generiert Tokens, um die Zugriffsberechtigungen des Emulators zu verwalten.
Server einschalten	Stellt eine direkte WebRTC-Verbindung zwischen dem Client und dem Server her. Der Turn-Server ist nur erforderlich, wenn der Emulatordienst hinter Firewalls oder Proxys ausgeführt wird.
Envoy	Ein Proxydienst für: Bieten Sie HTTPS mit einem selbst signierten Zertifikat an. Leiten Sie Traffic auf Port 80 (HTTP) an Port 443 (HTTPS) weiter. Als gRPC-Proxy für den Emulator fungieren. Prüfen Sie die Tokens, um den Zugriff auf den gRPC-Endpunkt des Emulators zuzulassen. Andere Anfragen an die Nginx-Komponente weiterleiten, auf der eine React-Anwendung gehostet wird.

Emulator auf einer Cloud-VM einrichten

So erstellen Sie ein GCP-Projekt:

Rufen Sie die Google Cloud Console auf und wählen Sie ein Projekt aus.
Informationen dazu, ob die Abrechnung für Ihr Google Cloud-Projekt aktiviert ist, finden Sie unter Abrechnung für ein Projekt aktivieren, deaktivieren oder ändern .
Aktivieren Sie die API.

Linux-VM in der Google Compute Engine erstellen

1. Verschachtelte Virtualisierung aktivieren

Standardmäßig ist die verschachtelte Virtualisierung auf Projekt-, Ordner- oder Organisationsebene zulässig. Solange also niemand in Ihrer Organisation die verschachtelte Virtualisierung deaktiviert hat, müssen Sie nichts unternehmen, um sie zu aktivieren.

Verwenden Sie das gcloud-Befehlszeilentool, um zu prüfen, ob die verschachtelte Virtualisierung zulässig ist:

gcloud beta resource-manager org-policies describe   \
  constraints/compute.disableNestedVirtualization  --effective --project=[PROJECT_ID]

2. Bootfähiges Ubuntu-18.04-lts-Laufwerk erstellen

Rufen Sie die Cloud Console auf.
Wählen Sie das GCP-Projekt aus.
Öffnen Sie das Navigationsmenü und wählen Sie Compute Engine > Laufwerke > Laufwerk erstellen aus.
1. Geben Sie einen Laufwerknamen an. Beispiel: ubuntu1804lts
2. Wählen Sie eine Region und eine Zone aus. Damit die verschachtelte Virtualisierung unterstützt wird, müssen die ausgewählte Region und Zone Haswell- oder neuere Prozessoren unterstützen. Weitere Informationen finden Sie unter Regionen und Zonen.
3. Quellbild von ubuntu-1804-bionic-v20210211 auswählen
4. Legen Sie eine geeignete Laufwerksgröße fest (100 GB oder mehr wird empfohlen).

Abbildung 2: Erstellen Sie ein bootfähiges Ubuntu-Laufwerk.

3. Benutzerdefiniertes Image mit speziellem Lizenzschlüssel zum Aktivieren von VMX erstellen

Rufen Sie die Cloud Console auf.

Öffnen Sie eine Cloud Shell und verwenden Sie den folgenden Befehl:

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"

Geben Sie einen Bildnamen ein. Beispiel: aaos-emulator-image
Legen Sie als Laufwerkzone die Zone fest, in der Sie das Laufwerk erstellt haben.
Legen Sie als Laufwerknamen den Namen fest, den Sie beim Erstellen des Laufwerks verwendet haben.

Beispiel:

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"

Weitere Informationen finden Sie unter VM-Instanz mit verschachtelter Virtualisierung.

4. VM-Instanz mit dem benutzerdefinierten Image erstellen

Rufen Sie die Cloud Console auf.
Wählen Sie das GCP-Projekt aus.
Klicken Sie auf das Navigationsmenü > „Compute Engine“ > „VM-Instanz“.

Abbildung 3: Erstellen Sie eine VM-Instanz.
Geben Sie einen Instanznamen ein. Beispiel: aaosemulator
Wählen Sie die gewünschte Maschinenfamilie und den gewünschten Typ aus. Die Maschine muss mindestens vier vCPUs und 16 GB Arbeitsspeicher haben.
Wählen Sie als CPU-Plattform „Intel Cascade Lake“ oder höher aus.
Ändern Sie das Bootlaufwerk in das im vorherigen Schritt erstellte Image.
Aktivieren Sie die Firewall für:
- HTTP-Traffic zulassen
- HTTPS-Traffic zulassen

5. Firewall so konfigurieren, dass die Ports 80 und 443 geöffnet werden

Rufen Sie die Cloud Console auf.
Wählen Sie das GCP-Projekt aus.
Klicken Sie auf das Navigationsmenü > Compute Engine > VM-Instanz > Firewallregel einrichten.

Erforderliche Software auf der VM installieren

Installieren Sie Python 3 und Python3-env:

sudo apt update
sudo apt install python3
sudo apt-get install python3-venv

Installieren Sie das Android SDK und ADB im Pfad.
```
sudo apt install android-sdk
```
Informationen zum Installieren von Docker und Docker-Compose finden Sie unter Docker und Docker-Compose. Achten Sie darauf, dass Sie diese als Nutzer ohne Root-Berechtigung ausführen können.
So prüfen Sie, ob die CPU die Hardwarevirtualisierung unterstützt (der Befehl sollte eine nicht nullwertige Zahl zurückgeben):
```
egrep -c '(vmx|svm)' /proc/cpuinfo
```
Installieren Sie die Kernel Virtual Machine (KVM). Führen Sie zum Installieren von KVM Folgendes aus:
```
sudo apt-get install qemu-kvm libvirt-daemon-system libvirt-clients bridge-utils
```

So prüfen Sie, ob KVM funktioniert:

sudo apt install cpu-checker
kvm-ok

Die Ausgabe sollte so aussehen:

INFO: /dev/kvm exists
KVM acceleration can be used

So installieren Sie Node.js und den Node Package Manager (NPM):
```
sudo apt install nodejs npm
```

Gehostete Container starten

Führen Sie zum Überprüfen der Installation die gehosteten Android Emulator-Container aus dem öffentlichen Repository aus. Weitere Informationen zu den Containern Sie können diese Container jetzt ausführen, ohne sie zu erstellen. Beispiel:
```
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
```
Dadurch wird der Container heruntergeladen (falls er nicht lokal verfügbar ist) und gestartet.
Stellen Sie nach dem Start des Containers eine Verbindung zum Gerät her, indem Sie ADB auf die gleiche Weise konfigurieren, wie Sie eine AVD auf einem lokalen Host verbinden. Beispiel:
```
adb connect localhost:5555
adb devices
```
Die Ausgabe sollte so aussehen:
```
List of devices attached
localhost:5555 device
```

AAOS-Emulatordienst einrichten

So richten Sie den Emulatordienst ein:

Installieren Sie das Docker-Container-Script für den Android-Emulator:

git clone https://github.com/google/android-emulator-container-scripts.git

cd android-emulator-container-script
source ./configure.sh

Dadurch wird eine virtuelle Umgebung aktiviert und das ausführbare emu-docker-Programm verfügbar gemacht. Wenn Sie detaillierte Informationen zur Verwendung erhalten möchten, starten Sie die Funktion:
```
emu-docker -h
```
Akzeptieren Sie die Lizenzvereinbarungen, um die Docker-Container zu erstellen.
Erstellen Sie den Docker-Container für den AAOS-Emulator.
Laden Sie einen Emulator-Build herunter, der höher als Version 7154743 ist. Beispiel:
```
sdk-repo-linux-emulator-7154743.zip
```
Laden Sie das AAOS-Emulator-System-Image herunter. Beispiel: sdk-repo-linux-system-images-7115454.zip:
```
emu-docker create <emulator-zip> <system-image-zip>
```
Erstellen Sie die Webcontainer und legen Sie einen Nutzernamen und ein Passwort für den Remotezugriff fest.
```
./create_web_container.sh -p user1,passwd1
```

Starten Sie den AAOS-Emulator-Webdienst:

docker-compose -f js/docker/docker-compose-build.yaml -f js/docker/development.yaml up

Sie haben einen AAOS-Emulator-Webdienst gestartet. So greifen Sie in einem Webbrowser darauf zu:

https://<VM_External__IP>

Fehlerbehebung

Wenn ein Verbindungsfehler mit der externen IP-Adresse der VM auftritt, prüfen Sie, ob die VM so eingerichtet ist, dass sowohl HTTP- als auch HTTPS-Traffic zugelassen wird. Weitere Informationen finden Sie unter Einfachen Apache-Webserver ausführen.

Turn-Server einrichten

Sie können jederzeit Ihren eigenen Abbiegeverwalter verwenden. Unten finden Sie ein Beispiel für eine Google Cloud-VM-Instanz.

Hinweis:Damit der TURN-Server auf einer Google Cloud-VM-Instanz funktioniert, müssen Sie die VM-Firewallregel so konfigurieren, dass Traffic auf den TCP- und UDP-Ports 3478 und 3479 zugelassen wird.

Installieren Sie den Coturn-Server:

sudo apt install coturn
systemctl stop coturn
echo "TURNSERVER_ENABLED=1"|sudo tee -a /etc/default/coturn

Ändern Sie /etc/turnserver.conf, indem Sie die folgenden Zeilen hinzufügen:

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

Ändern Sie die Docker Compose-YAML-Datei so, dass die TURN-Konfiguration enthalten ist:
```
cd android-emulator-container-script
nano  js/docker/docker-compose-build.yaml
```

Fügen Sie im Abschnitt „emulator“ die folgenden beiden Umgebungszeilen hinzu:

     shm_size: 128M
     expose:
       - "8554"
+    environment:
+       - TURN=printf $SNIPPET

Starten Sie den AAOS-Emulatordienst mit der Abbiegeverkonfiguration neu. Ersetzen Sie die IP-Adresse, den Nutzernamen und die Anmeldedaten des TURN-Servers unten durch Ihre eigenen:
```
export SNIPPET="{\"iceServers\":[{\"urls\":\"turn:35.193.52.134:3478\",\"username\":\"test\",\"credential\":\"test123\"}]}"
docker-compose -f js/docker/docker-compose-build.yaml up
```