Introduction

    IEC Type3 mainly focus on Android Application running on edge ARM Cloud architecture with GPU/ vGPU Management. Also, ARM cloud games need to have the basic features of "cloud”, such as flexibility ,

availability everywhere. Based on cloud infrastructure optimized for android application, providing ARM application services.

How to use this document

    This document describes the construction, compilation and use of robox Android container environment. Introduce environment configuration, code download, build and compile, and how to use it.

    This document is mainly suitable for users who build and compile robox container Android emulation.

Deployment Architecture

                                                                                                                                                 Figure1     Deployment Main Framework

                                                                                                                  Figure2    Robox Framework

Pre-Installation Requirements

• Hardware Requirements

2*arm64 server:

ARM Server satisfies the Arm Server Ready certified.

• Software Perequisites

• Components Version

• Database Perequisites

schema scripts: N/A

• Other Installation Requirements

  • Jump Host Requirements：N/A

  • Network Requirements:  The network connection is normal and can communicate with the external network.

  • Bare Metal Node Requirements ：N/A

  • Execution Requirements (Bare Metal Only) ：N/A

Installation High-Level Overview

Bare Metal Deployment Guide 

• Install Bare Metal Jump Host : N/A

• Creating a Node Inventory File: N/A

• Creating the Settings Files: N/A

• Running: N/A

Upstream Deployment Guide

• Upstream Deployment Key Features ：N/A

• Special Requirements for Upstream Deployments ：N/A

• Scenarios and Deploy Settings for Upstream Deployments ：N/A

• Including Upstream Patches with Deployment：N/A

• Running： N/A

• Interacting with Containerized Overcloud： N/A

Verifying the Setup as defined the Akraino validation feature project plus any additional testing specific to the blue print

Install Main Components

       Since the components and images required by the project are relatively large, and the process of  compilation takes time, we store the compiled images on the github repository.

The link is: https://github.com/ysemi-computing/RoboxWidget.git

git clone https://github.com/ysemi-computing/RoboxWidget.git

After this step,  The code structure is as follows:

RoboxWidget/

├── android.img

├── components

├── grafana-server 

├── node_exporter

├── perf_exporter

└── prometheus

└── README.md

Run Anbox On Ubuntu18.04

Build Android image for anbox

        Code cloning and compilation is very time-consuming. If you just want to deploy and experience the Android system by iec, you can skip this section, because the project you just cloned already exists.

Firstly, you should install a ubuntu 18.04 system on Aarch64 processor, and swith to root user, then run the script “build_android_image.sh”。

After about two hours, the Android image was compiled successfully,  and the results are as follows:

ls out/target/product/arm64/

android-info.txt  obj   previous_build_config.mk  recovery  symbols  system.img  build_fingerprint.txt  cache.img  data  gen  module-info.json    ramdisk.img    root  system   userdata.img

Required packages installation

   Before running anbox, we need to install some necessary packages, you can execute the fol script “arm64_env_setup.sh”

After this,  the image of anbox has been completed, which can be viewed through docker related commands。Type the command below:

sudo docker images | grep robox

android                                                               robox                          e223a91c4b58   6 days ago      860MB

Run robox android system

After the above two scripts are executed, the robox operating environment is ready, and the entire directory structure of robox can be seen as follows

├── android

├── binaryFiles

├── cmake

├── cmake_uninstall.cmake.in

├── COPYING.GPL

├── cross-compile-chroot.sh

├── data

├── docs

├── external

├── kernel

├── patch

├── products

├── scripts

├── src

Step1: You can copy the binaryFiles in the robox code to the some place, then run robox

start the first continer instance

./robox -v start 1

       1 is the id, used by session manager and docker container

Step2: Check the docker instance process and session manager process.

sudo docker ps | grep instance

ps -aux | grep session

step3: Log in the container and confirm whether the robox instance started successfully.

   container name format:  instance + id

docker exec -it instance1 sh      

step4: get android property sys.boot_completed

getprop | grep sys.boot.completed

[sys.boot_completed]: [1]  //1 which means start successfully

Cluster deployment and access by K8S

        It is troublesome to start robox through commands to deploy in a real environment. Here, the well-known K8S system is used to complete the deployment of robox instances. On this basis,

Robox can be much more effectively deployed, run, monitored, and analyzed for multiple host nodes. Here is k8s cluster setup and container orchestration.

1 Basic Architecture

                                                                            Figure3    View Of Robox In Cluster

2 K8s Cluster construction

        The k8s cluster construction can be completed through the warehouse code, you can do as follows

git clone https://gerrit.akraino.org/r/iec.git

cd iec/deploy/compass && bash deployIEC.sh

current configuration:

• Ubuntu Version：18.04
• Docker: 20+
• k8s: 1.21.3

Host Network:

• master: 192.168.10.66
• work:   192.168.10.62

3 Check cluster running status

   kubectl apply -f https://addons.kuboard.cn/kuboard/kuboard-v3-swr.yaml

kubectl get cs 

Warning: v1 ComponentStatus is deprecated in v1.19+

NAME                 STATUS    MESSAGE             ERROR

scheduler            Healthy   ok                 

controller-manager   Healthy   ok                 

etcd-0               Healthy   {"health":"true"}  

kubectl get node

NAME     STATUS   ROLES                  AGE   VERSION

master   Ready    control-plane,master   22h   v1.21.3

work     Ready    <none>                 22h   v1.21.5

          At the same time, we can present the status of the cluster through the k8s visual component. We use kuboard, it is very convenient to install and use.

      then start kuboard with web browser

url：master-ip-address:30080

user：admin

password：Kuboard123

                                                                                                         Figure4    View of Robox On Kuboard

Cloud platform monitoring & Analyze

1 Basic Architecture

                                                                                                   Figure5    Prometheus and Grafana Mix

2 Bootup basic components

     Prometheus is only used for monitoring data. The real data needs an exporter. Different exporters export different data,These data are finally presented by prometheus.

Only node exporter and perf exporter are used in this project, these two can be directly downloaded and installed with binary files. Prometheus is used for data monitoring,

and then a better visual interface is grafana, the data it needs can just be obtained through Prometheus.

     This project only needs to run the script below

https://github.com/ysemi-computing/RoboxWidget/blob/main/scripts/load_components.sh

     After the script is executed, the required Prometheus and grafana are downloaded and run in the background

3 Analyze data by web browser

     Let us explore data that Prometheus has collected about itself. To use Prometheus's built-in expression browser, navigate to http://localhost:9090/graph and choose the "Table" view

within the "Graph" tab. Enter the below into the expression console and then click "Execute":

      prometheus_target_interval_length_seconds

                                                                                                                   Figure6    First Startup View Of Prometheus

In addition, we can log in to grafana through a web browser and see the effect as shown below

url: http://localhost:3000

user: admin

password: admin

                                                                                                                   Figure7     First Startup View Of Grafana

Developer Guide and Troubleshooting

• Utilization of Images

N/A

• Post-deployment Configuration

N/A

• Debugging Failures 

N/A

• Reporting a Bug

N/A

Uninstall Guide

N/A

Troubleshooting

When the server restarts, the binder_linux module needs to be loaded and installed as follows：

sudo modprobe ashmem_linux

sudo rmmod binder_linux || true; sudo modprobe binder_linux num_devices=254

sudo chmod 777 /dev/ashmem /dev/binder*

If there is an external graphics card, you need to manually disable the built-in graphics card after each server restart. for example:

lspci | grep -in VGA

6:0007:41:00.0 VGA compatible controller: Huawei Technologies Co., Ltd. Hi1710 [iBMC Intelligent Management system chip w/VGA support] (rev 01)

echo 1 > /sys/bus/pci/devices/0007\:41\:00.0/remove

Maintenance

• Blue Print Package Maintenance

• Software maintenance： N/A 

• Hardware maintenance：N/A

• Blue Print Deployment Maintenance (N/A)

Frequently Asked Questions

N/A

License

N/A

References

N/A

Definitions, acronyms and abbreviations

N/A

When porting an Android app to Anbox Cloud (usually in the form of an APK), there are a few issues that might cause your app to not function properly: